Moseri-de Bruijni järjestuse generaator | Neljandate astmete kalkulaator

Mis on Moser-de Bruijni jada?

Moser-de Bruijni jada koosneb arvudest, mida saab väljendada 4 eristavatest astmetest summadena. Nimetatud matemaatikute Leo Moser ja Nicolaas Govert de Bruijni järgi algab jada nii: 0, 1, 4, 5, 16, 17, 20, 21, 64, 65, 68, 69, 80, 81, 84, 85...

Mis teeb selle jada huvitavaks? Kui kirjutate ükskõik millise liikme 4-süsteemis, näete ainult numbreid 0 ja 1 - mitte kunagi 2 ega 3. See tähendab, et iga arv on ehitatud 4 astmete (nagu 4⁰, 4¹, 4², 4³) liitmisel, kus iga aste esineb kas üks kord või üldse mitte.

Siin on praktiline näide: Arv 21 esineb jadAs, sest see võrdub 16 + 4 + 1-ga, mis on 4² + 4¹ + 4⁰. 4-süsteemis kirjutatakse see kui "111" - ainult 0-d ja 1-d. Võrrelge seda arvuga 22, mis vajaks oma 4-süsteemi esituses "2"-d (122), seega see ei sobi.

Jada ilmub aditiivses arvuteooorias, kombinatoorika valdkonnas ja summavabade hulkade uurimisel. Mõelge sellest kui 4-süsteemi sugulasest binaarsüsteemile - selle asemel, et töötada 2 astmetega, töötate 4 astmetega. See loob märksa hõredama jada, kuna enamik täisarvudest jäetakse vahele.

Kuidas kasutada Moser-de Bruijni järjendi generaatorit

Selle generaatori kasutamine on lihtne:

1. Sisestage, mitu liiget soovite (vaikimisi 20, kui jätate tühjaks)
2. Vajutage "Genereeri" järjendi arvutamiseks
3. Teie tulemused ilmuvad kohe loendina allpool
4. Soovite teisi numbreid? Muutke lihtsalt sisendit ja genereerige uuesti

Arvutused toimuvad täielikult teie brauseris JavaScripti abil, seega puudub serveripoolne viivitus või interneti sõltuvus - see on kiire ja töötab võrguühenduseta pärast lehe laadimist.

Sisendi kontrollimine ja piirangud

Generaator kontrollib teie sisendit vigade vältimiseks:

• Peab olema positiivne täisarv (ilma kümnendkohtadeta või negatiivse väärtuseta)
• Maksimaalselt 1000 liiget brauseri aeglustumise vältimiseks
• Mittenuumerliku sisendi korral kuvatakse veateade
• Tühja välja korral genereeritakse vaikimisi 20 liiget

Miks 1000-liikmelise järjendi piirang? Kuigi algoritm on tõhus, võib tuhandete liikmete genereerimine koormata brauseri mälu, eriti mobiilseadmetel. Tegelikkuses ei ole teil harva vaja rohkem kui 100-200 liiget enamiku matemaatiliste analüüside või hariduslike eesmärkide jaoks.

Moser-de Bruijn järjestiku valemi mõistmine

Saate Moser-de Bruijn järjestikku defineerida kolmel samaväärsel viisil, mis pakuvad erinevaid vaatenurki:

Kolm viisi järjestiku defineerimisel

Liiteline kuju (4 astmed): Arv n kuulub järjestikku, kui saate selle kirjutada kujul: $n = \sum_{i \in S} 4^i$ kus S on mis tahes mittenegatiivse täisarvude hulk. Iga 4 aste võib esineda üks kord või mitte üldse - kordusi ei lubata.

Nelja-aluseline esitus (Lihtsaim test): Teisendage arv nelja-alusesse. Kui näete ainult 0-sid ja 1-sid (ilma 2-de ja 3-deta), kuulub see järjestikku. See on käsitsi liikmelisuse kontrollimise kiireim viis.

Binaarne vastavus (Arvutamiseks kõige kasulikum): Et leida n-s liige (alustades n=0-st): $M(n) = \sum_{i=0}^{k} b_i \cdot 4^i$ kus $b_i$ on n binaarsed numbrid. Tõlgendus: Võtke oma indeksi binaarne esitus, seejärel asendage iga "1" bitt vastava 4 astmega.

Töötavad näited

Vaatame, kuidas need definitsioonid toimivad:

• n = 0 (binaarne: 0) → M(0) = 0
• n = 1 (binaarne: 1) → M(1) = 4⁰ = 1
• n = 2 (binaarne: 10) → M(2) = 4¹ = 4
• n = 3 (binaarne: 11) → M(3) = 4¹ + 4⁰ = 5
• n = 5 (binaarne: 101) → M(5) = 4² + 4⁰ = 17

Binaarne vastavusmeetod on see, mida see generaator kasutab - see on arvutuslikult tõhus, kuna bitilised operatsioonid on kiired.

Moser-de Bruijni järjendi arvutamine

Generaatori algoritm

Generaator kasutab binaarkorrepondentsi, kuna see on kiire ja lihtne:

Samm-sammult protsess:

1. Korda iga indeksi i läbi 0-st kuni n-1-ni (n on teie soovitud termite arv)
2. Indeksi i jaoks vaata selle binaarest kujutist
3. Iga "1" biti jaoks positsioonil j, lisa 4^j oma jooksvale summale
4. See summa saab i-ndaks termiks

Näide: 6. termi (indeks 5) leidmine

Arvutame M(5) samm-sammult:

• Indeks 5 binaarselt: 101
• Bit 0 (parempool) = 1 → lisa 4⁰ = 1
• Bit 1 (keskmine) = 0 → lisa midagi
• Bit 2 (vasakpool) = 1 → lisa 4² = 16
• Lõpptulemus: 1 + 16 = 17

See meetod toimib hästi. Suurte indeksite puhul teete põhimõtteliselt bitivahetust ja liitmist—operatsioone, mida kaasaegsed protsessorid väga kiiresti töötlevad.

Kontrollimine, kas number kuulub järjendisse

Soovite kontrollida, kas konkreetne number kuulub Moser-de Bruijni järjendisse? Kasutage base-4 testi:

1. Teisendage number base-4 süsteemi
2. Uurige numbrid—kas näete ainult 0-sid ja 1-sid?
3. Kui jah, kuulub see järjendisse. Kui leiate 2 või 3, ei kuulu.

Näide: Kas 85 on järjendis?

• 85 base-4: 1111 (see on 64 + 16 + 4 + 1)
• Sisaldab ainult 1-si → Jah, 85 on järjendis

Vastunäide: Kas 90 on järjendis?

• 90 base-4: 1122
• Sisaldab numbrit 2 → Ei, 90 ei ole järjendis

Generaator rakendab seda JavaScripti bitiliste operaatorite abil, mis on keelele omased ja kaasaegsetes brauserites väga optimeeritud.

Ühikud ja täpsus

Moser-de Bruijni järjend tegeleb puhtate täisarvudega:

• Kõik termid on mittenegatiivsed täisarvud (0, 1, 4, 5, 16 jne.)
• Pole ühikuid, kümnendmurde ega ümardamist
• Tulemused on matemaatiliselt täpsed—saate igal korral täpsed täisarvud
• Kasv on eksponentsiaalne: n-s term võib ulatuda kuni ligikaudu 4^(⌊log₂(n)⌋+1) - 1

See eksponentsiaalne kasv tähendab, et järjend muutub kiiresti suureks. 20. term on juba 340 ja 100. termiks olete tegelenud miljonite numbritega.

Reaalsed rakendused ja kasutusjuhud

Haridus ja õppimine

Arvusüsteemide õpetamine: Kui olen seda klassitoas kasutanud, mõistavad õpilased baasiteisendusi palju kiiremini, kui nad saavad mängida Moser-de Bruijni järjestikuga. See ühendab kahe- (alus 2) ja keerulisemate arvusüsteemide vahelise lõhe. Õpilased näevad kohe, kuidas aluse muutmine mõjutab järjestiku tihedust.

Bitimaniputseerimise mõistmine: Arvutiteaduse üliõpilased saavad kasu sellest, kui nad näevad otsest seost binaarse esituse ja matemaatiliste järjestike vahel. Algoritm näitab, kuidas bittide manipuleerimine tõlgendub reaalseteks matemaatilisteks objektideks – mitte ainult abstraktseteks toiminguteks.

Uurimine ja analüüs

Kombinatoorika ja summavabad hulgad: Uurijad, kes uurivad liituvaid aluseid, kasutavad selliseid järjestikke, et uurida, millised hulgad võimaldavad ainulaadseid esitusi. Moser-de Bruijni järjestik on õpiku näide hulgast, kus igal esitataval arvul on täpselt üks esitus.

Liitarvu teooria: Järjestik aitab uurida küsimusi selle kohta, kuidas täisarve saab lahutada summadeks. See on seotud probleemidega Täisarvude järjestike veebiväljaandes (OEIS), kus see on kataloogitud kui A000695.

Praktiline programmeerimine

Algoritmi disain: Genereerimisalgoritm näitab efektiivset järjestiku konstrueerimist. Saate genereerida tuhandeid liikmeid minimaalsete arvutuskuludega, muutes selle kasulikuks algoritmi võrdlemiseks või efektiivsete koodimudelite õpetamiseks.

Mustri tuvastamise ülesanded: Kui töötate hõredate täisarvuhulkade või andmete tihendamisskeemidega, aitab Moser-de Bruijni järjestiku käitumise mõistmine kujundada otsuseid kodeerimisstrateegiate kohta.

Seotud matemaatilised jadad

Kui Moser-de Bruijni jada pakub teile huvi, siis need seotud jadad pakuvad sarnaseid mustreid erinevate aluste või piirangutega:

Otsesed sugulased

Kahe astmed (OEIS A000079): 1, 2, 4, 8, 16, 32... Lihtsaim liiteline alus. Iga kahe aste ilmub täpselt üks kord, moodustades binaarsete numbrite ehituskivid.

Kõik mittenegatiivsed täisarvud (binaarsed summad): 0, 1, 2, 3, 4, 5, 6, 7... Kui lubate mis tahes erinevate kahe astmete summa, saate kõik võimalikud täisarvud—seda teeb binaarne esitus.

Erinevate kolme astmete summad (OEIS A005836): 0, 1, 3, 4, 9, 10, 12, 13... Sama kontseptsioon kui Moser-de Bruijni jadal, kuid kasutades kahe asemel kolme astmeid. Need on arvud, mille kolmanda astme esitus sisaldab ainult 0-sid ja 1-sid.

Huvitavad variandid

Fibbinaar arvud (OEIS A003714): 0, 1, 2, 4, 5, 8, 9, 10... Arvud, mille binaarne kuju ei sisalda järjestikusi ühtesid. Seotud Fibonacci arvusüsteemide ja Zeckendorfi teoreemiga.

Stanley jada: Moser-de Bruijni jada kolmanda astme analoog—arvud, mille kolmanda astme esitus ei sisalda ühtegi 1-st (lubatud on ainult 0-d ja 2-d).

Kust veel rohkem teada saada

Täisarvude järjestuste internetientsüklopeedia (OEIS) kataloogib sadu tuhandeid jadad. Otsige termineid nagu "liiteline alus", "summavaba hulk" või "erinevad astmed", et leida seotud jadad. Moser-de Bruijni jada ise on A000695 OEIS andmebaasis.

Ajalooline taust

Matemaatikud järjendi taga

Leo Moser (1921-1970) ja Nicolaas Govert de Bruijn (1918-2012) tegid mõlemad püsivaid panuseid matemaatikasse, kuigi nad tulid erinevatest taustsüsteemidest. Moser, Austria-Kanada matemaatik, töötas ulatuslikult arvuteooria, kombinatoorikas ja geomeetrias - te võite tema nime tunda Erdős–Moseri võrrandist. De Bruijn, Hollandi matemaatik, jättis oma jälje kombinatoorikas, graafiteooriasse ja arvutiteadusesse. Tema de Bruijni järjestused (erinevad sellest) on põhilised kodeerimisteooriates ja endiselt laialt kasutatavad tänapäeval.

Nende nimelised järjestused tekkisid 1960. aastatel liitarvu teooria uurimisel. Matemaatikud küsisid: millised täisarvude komplektid võimaldavad teisi täisarve ainulaadselt esitada summadena? Neljakordse astme arvud osutusid üheks selliseks komplektiks, ja Moseri-de Bruijni järjestus hõlmab kõiki võimalikke summasid, mida saab luua.

Miks see oluline on

Järjestus asub laiemas liitbaaside uurimises - täisarvude komplektides, mis võimaldavad teisi täisarve liitmise kaudu luua. Mõned baasid võimaldavad ainulaadset esitust (nagu neljakordse astme arvud), teised mitte. Arusaamine, millised baasid millised omadused omavad, jääb liitarvu teooria aktiivse uurimise valdkonnaks.

Te leiate selle järjestuse A000695 OEIS-st, kus matemaatikud on dokumenteerinud selle seoseid binaarse esituse, kvaternaarse (4-põhjalise) süsteemi ja kombinatoorsete omadustega. Kaasaegne arvutiteadus on leidnud sellele uusi kasutusvõimalusi, eriti algoritmides, mis hõlmavad bittide manipuleerimist ja hõreda andmestruktuuri tõhusat kodeerimist.

Koodiimplementatsiooni näited

Soovite ise Moser-de Bruijni järjendi generaatorit rakendada? Siin on tõhusad implementatsioonid populaarsetes programmeerimiskeeltes. Iga näide sisaldab nii järjendi generaatorit kui ka liikmeksoleku testi funktsiooni.

1def moser_de_bruijn(n):
2    """Genereeri Moser-de Bruijni järjendi esimesed n liiget."""
3    sequence = []
4    for i in range(n):
5        term = 0
6        power = 1
7        temp = i
8        while temp > 0:
9            if temp & 1:  # Kontrolli, kas kõige vähem oluline bitt on 1
10                term += power
11            power *= 4
12            temp >>= 1  # Nihuta paremale järgmise bitti kontrollimiseks
13        sequence.append(term)
14    return sequence
15
16# Näidiskasutus:
17terms = moser_de_bruijn(20)
18print("Moser-de Bruijni järjendi esimesed 20 liiget:")
19print(terms)
20# Väljund: [0, 1, 4, 5, 16, 17, 20, 21, 64, 65, 68, 69, 80, 81, 84, 85, 256, 257, 260, 261]
21
22def is_moser_de_bruijn(num):
23    """Kontrolli, kas number on Moser-de Bruijni järjendis."""
24    while num > 0:
25        digit = num % 4
26        if digit > 1:
27            return False
28        num //= 4
29    return True
30
31# Kontrolli, kas 21 on järjendis
32print(f"Kas 21 on järjendis? {is_moser_de_bruijn(21)}")  # Tõene
33print(f"Kas 22 on järjendis? {is_moser_de_bruijn(22)}")  # Väär
34

1function moserDeBruijn(n) {
2  const sequence = [];
3  for (let i = 0; i < n; i++) {
4    let term = 0;
5    let power = 1;
6    let temp = i;
7    while (temp > 0) {
8      if (temp & 1) {  // Kontrolli, kas kõige vähem oluline bitt on 1
9        term += power;
10      }
11      power *= 4;
12      temp >>= 1;  // Nihuta paremale järgmise bitti kontrollimiseks
13    }
14    sequence.push(term);
15  }
16  return sequence;
17}
18
19// Näidiskasutus:
20const terms = moserDeBruijn(20);
21console.log("Moser-de Bruijni järjendi esimesed 20 liiget:");
22console.log(terms);
23// Väljund: [0, 1, 4, 5, 16, 17, 20, 21, 64, 65, 68, 69, 80, 81, 84, 85, 256, 257, 260, 261]
24
25function isMoserDeBruijn(num) {
26  while (num > 0) {
27    const digit = num % 4;
28    if (digit > 1) {
29      return false;
30    }
31    num = Math.floor(num / 4);
32  }
33  return true;
34}
35
36// Kontrolli konkreetseid numbreid
37console.log(`Kas 21 on järjendis? ${isMoserDeBruijn(21)}`);  // tõene
38console.log(`Kas 22 on järjendis? ${isMoserDeBruijn(22)}`);  // väär
39

1import java.util.ArrayList;
2import java.util.List;
3
4public class MoserDeBruijnGenerator {
5    
6    public static List<Integer> generateSequence(int n) {
7        List<Integer> sequence = new ArrayList<>();
8        for (int i = 0; i < n; i++) {
9            int term = 0;
10            int power = 1;
11            int temp = i;
12            while (temp > 0) {
13                if ((temp & 1) == 1) {  // Kontrolli, kas kõige vähem oluline bitt on 1
14                    term += power;
15                }
16                power *= 4;
17                temp >>= 1;  // Nihuta paremale järgmise bitti kontrollimiseks
18            }
19            sequence.add(term);
20        }
21        return sequence;
22    }
23    
24    public static boolean isMoserDeBruijn(int num) {
25        while (num > 0) {
26            int digit = num % 4;
27            if (digit > 1) {
28                return false;
29            }
30            num /= 4;
31        }
32        return true;
33    }
34    
35    public static void main(String[] args) {
36        List<Integer> terms = generateSequence(20);
37        System.out.println("Moser-de Bruijni järjendi esimesed 20 liiget:");
38        System.out.println(terms);
39        
40        System.out.println("Kas 21 on järjendis? " + isMoserDeBruijn(21));  // tõene
41        System.out.println("Kas 22 on järjendis? " + isMoserDeBruijn(22));  // väär
42    }
43}
44

1#include <iostream>
2#include <vector>
3
4std::vector<int> moserDeBruijn(int n) {
5    std::vector<int> sequence;
6    for (int i = 0; i < n; i++) {
7        int term = 0;
8        int power = 1;
9        int temp = i;
10        while (temp > 0) {
11            if (temp & 1) {  // Kontrolli, kas kõige vähem oluline bitt on 1
12                term += power;
13            }
14            power *= 4;
15            temp >>= 1;  // Nihuta paremale järgmise bitti kontrollimiseks
16        }
17        sequence.push_back(term);
18    }
19    return sequence;
20}
21
22bool isMoserDeBruijn(int num) {
23    while (num > 0) {
24        int digit = num % 4;
25        if (digit > 1) {
26            return false;
27        }
28        num /= 4;
29    }
30    return true;
31}
32
33int main() {
34    std::vector<int> terms = moserDeBruijn(20);
35    std::cout << "Moser-de Bruijni järjendi esimesed 20 liiget:" << std::endl;
36    for (int term : terms) {
37        std::cout << term << " ";
38    }
39    std::cout << std::endl;
40    
41    std::cout << "Kas 21 on järjendis? " << (isMoserDeBruijn(21) ? "tõene" : "väär") << std::endl;
42    std::cout << "Kas 22 on järjendis? " << (isMoserDeBruijn(22) ? "tõene" : "väär") << std::endl;
43    
44    return 0;
45}
46

Võtmeimplementatsiooni ülevaade

Kõik need implementatsioonid järgivad sama mustrit: kasutada bitimaskimise operatsioone indeksi binaarse esituse lugemiseks ning seejärel konstrueerida vastav 4 astmete summa. Liikmeksoleku testi funktsioonid kasutavad baas-4 lähenemist - kontrollides, kas numbrid on piiratud 0 ja 1-ga.

Jõudluse seisukohalt on need implementatsioonid väga tõhusad. Ajaline keerukus on O(n × log n) n liikme genereerimisel, kuna iga liige nõuab O(log i) bitide läbivaatamist. Üksiku numbri liikmeksoleku kontrollimine on O(log N), kus N on kontrollitav number.

Üksikasjalikud arvulised näited

Allolev tabel näitab esimesi 32 liiget koos täieliku lahutusega. Pange tähele, kuidas base-4 esitus sisaldab ainult 0-sid ja 1-sid ning kuidas lahutus vastab otse binaarsele indeksile:

Üksikasjalik vaade liikmele 21

Vaatame liiget 21 täielikult:

• Kümnendmurru väärtus: 21
• Base-4 esitus: 111 (kasutab ainult 0 ja 1 ✓)
• Järjestuse indeks: 7
• Binaarne indeks: 111 (binaarne 7 jaoks)
• Lahutus: 21 = 16 + 4 + 1 = 4² + 4¹ + 4⁰

Näete mustrit? Binaarne indeks (111) vastab otse sellele, millised 4 astmed kaasata. Iga "1" bitt ütleb, milline aste kaasata.

Kasvumustri vaatlemine

Järjestus kasvab eksponentsiaalselt—n-s liige on ligikaudu proportsionaalne 4^(log₂(n)). Mida see praktikas tähendab?

• 10. liikmeni jõuate 68-ni
• 20. liikmeni jõuate 272-ni
• 100. liikmeni jõuate miljonitesse

Mida suuremaks numbrid lähevad, seda hõredamaks järjestus muutub. Te jätate vahele üha rohkem täisarve. Vaatamata sellele hõredusele sisaldab järjestus lõpmatult palju liikmeid—see ei lõppe kunagi kasvamast.

Viited ja edasine lugemine

Esmased allikad

1. OEIS A000695 - Moser-de Bruijn'i jada. Täisarvude jadade elektrooniline entsüklopeedia. Põhjalik andmestik ja jada omadused.

2. De Bruijn, N. G. "Täisarvude hulga alustest." Publicationes Mathematicae Debrecen, kd. 1, 1950, lk. 232-242. Aluslik artikkel, mis kehtestab liituvate aluste põhiomadused.

3. Moser, Leo. "Genereerivate seeriate rakendus." Mathematics Magazine, kd. 35, nr. 1, 1962, lk. 37-38. Varajane töö jada genereerivate funktsioonide uurimisel.

Täiendav matemaatiline kontekst

4. Stolarsky, Kenneth B. "Digitaalsete summade võimsus- ja eksponentsiaalse summade seos binoomkoefitsientide paarsusega." SIAM Journal on Applied Mathematics, kd. 32, nr. 4, 1977, lk. 717-730. Uurib digitaalsete summade omadusi seoses Moser-de Bruijn'i jadataoliste järjenditega.

5. Allouche, Jean-Paul ja Jeffrey Shallit. Automaatsed jadad: Teooria, rakendused, üldistused. Cambridge University Press, 2003. Peatükk automaatsetest jadadest, sealhulgas ühendused Moser-de Bruijn'i jadaga.

Seotud mõisted

6. Summavabad hulgad - Wikipedia. Taust liitva arvuteooria laiemast kontekstist.

7. Liituvad alused - Wikipedia. Ülevaade hulkadest, mis võivad esitada täisarve summadena.

Korduma Kippuvad Küsimused

Milleks kasutatakse Moser-de Bruijni järjendit?

Järjendil on mitu rakendust: arvuteooria uuringud liitarvude aluste uurimisel, kombinatoorika tööd summa-vabadest hulkadest, arvutiteaduse haridus (eriti bitiliste operatsioonide ja efektiivsete algoritmide õpetamisel) ning matemaatiliste mustrite analüüs. See on suurepärane õppevahend erinevate arvusüsteemide omavaheliseks mõistmiseks.

Kuidas genereeritakse Moser-de Bruijni järjendit?

Võta iga indeks n alates 0-st, teisenda see kahendarvuks, seejärel asenda iga "1" bitt vastava 4 astmega. Näiteks indeksil 5 on kahendkujutis 101, seega arvuta 4² + 4⁰ = 16 + 1 = 17. See on 5. liige (alates indeksist 0).

Mis teeb Moser-de Bruijni järjendi eriliseks?

Igal järjendi arvul on eriline omadus: selle nelja-aluseline esitus sisaldab ainult 0-sid ja 1-sid - mitte kunagi 2-sid ega 3-sid. See tähendab, et saad iga liikme luua 4 astmete liitmisel, kus iga aste esineb kõige rohkem üks kord. See on sarnane kahendarvule, kuid kasutab 2 asemel 4 astmeid.

Kuidas kontrollida, kas konkreetne arv on järjendis?

Teisenda arv nelja-alusesse ja vaata numbrites. Kui näed ainult 0-sid ja 1-sid, on see järjendis. Kui ükskõik milline number on 2 või 3, siis ei ole. Näiteks 21 nelja-alusena on 111 (kõik 1-d ja 0-d), seega on sees. Aga 22 nelja-alusena on 112 (sisaldab 2-te), seega ei ole.

Mis on n-nda liikme valem?

N-s liige M(n) järgib seda valemit: M(n) = Σ(b_i × 4^i), kus b_i tähistab n kahendarvulisi numbrid. Lihtsalt öeldes: kirjuta n kahendarvuna, seejärel iga positsiooni puhul, kus on 1, lisa vastav 4 aste.

Kas järjend on lõpmatu?

Jah, see kestab igavesti. Moser-de Bruijni järjendis on lõpmata liikmeid. Siiski, mida kõrgemale minnakse, seda hõredamaks järjend muutub - vahele jäetakse järjest rohkem tavalisi täisarve.

Kuidas see erineb kahendarvulistest järjenditest?

Kahendarvulised järjendid (2 astmete summad) saavad esitada iga mittenegatiivse täisarvu - seda teebki kahendkujutis. Moser-de Bruijni järjend kasutab 4 astmeid, mis loob märksa hõredama hulga. Enamik täisarvudest ei esine Moser-de Bruijni järjendis.

Kes selle järjendi avastas?

Leo Moser (1921-1970), Austria-Kanada matemaatik, ja Nicolaas Govert de Bruijn (1918-2012), Hollandi matemaatik, uurisid mõlemad seda järjendit põhjalikult 1960-ndatel kui osa liitarvude teooria uuringutest. Järjend kannab mõlema nime.

Valmis uurima?

See generaator töötab täielikult teie brauseris – mingit installimist, registreerimist ega ootamist pole vaja. Olgu te siis üliõpilane, kes õpib arvusüsteemidest, teadlane, kes uurib liitarvulisi aluseid, või lihtsalt matemaatiliselt uudishimulik, saate te kohe genereerida termineid ja ise näha mustreid. Proovige genereerida erinevaid koguseid, et vaadelda, kuidas järjestik kasvab ja millised täisarvud kaasatakse.