Générateur de Séquence de Moser-de Bruijn

Qu'est-ce que la suite de Moser-de Bruijn ?

La suite de Moser-de Bruijn se compose de nombres qui peuvent être exprimés comme des sommes de puissances distinctes de 4. Nommée d'après les mathématiciens Leo Moser et Nicolaas Govert de Bruijn, la suite commence : 0, 1, 4, 5, 16, 17, 20, 21, 64, 65, 68, 69, 80, 81, 84, 85...

Qu'est-ce qui rend cette suite intéressante ? Lorsque vous écrivez un terme en base 4, vous ne verrez que les chiffres 0 et 1 — jamais 2 ou 3. Cela signifie que chaque nombre est construit en additionnant des puissances de 4 (comme 4⁰, 4¹, 4², 4³), où chaque puissance apparaît une fois ou pas du tout.

Voici un exemple pratique : Le nombre 21 apparaît dans la suite car il est égal à 16 + 4 + 1, ce qui est 4² + 4¹ + 4⁰. En base 4, cela s'écrit "111" — uniquement des 0 et des 1. Comparez cela avec 22, qui nécessiterait un "2" dans sa représentation en base 4 (122), donc il n'est pas inclus.

La suite apparaît dans la théorie additive des nombres, la combinatoire et la recherche sur les ensembles sans somme. Pensez-y comme à un cousin en base 4 du système binaire — au lieu des puissances de 2, vous travaillez avec des puissances de 4. Cela crée une suite beaucoup plus clairsemée car la plupart des entiers sont ignorés.

Comment utiliser le générateur de séquence de Moser-de Bruijn

L'utilisation de ce générateur est simple :

Entrez le nombre de termes que vous souhaitez (par défaut 20 si vous laissez le champ vide)
Cliquez sur "Générer" pour calculer la séquence
Vos résultats apparaissent instantanément dans une liste ci-dessous
Vous voulez d'autres nombres ? Modifiez simplement l'entrée et générez à nouveau

Les calculs sont entièrement exécutés dans votre navigateur à l'aide de JavaScript, donc il n'y a pas de délai serveur ou de dépendance Internet - c'est rapide et fonctionne hors ligne une fois la page chargée.

Validation des entrées et limites

Le générateur valide votre entrée pour prévenir les erreurs :

Doit être un nombre entier positif (pas de décimales ou de valeurs négatives)
Maximum de 1000 termes pour éviter les ralentissements du navigateur
Les entrées non numériques déclenchent un message d'erreur
Laissez le champ vide et vous obtiendrez 20 termes par défaut

Pourquoi la limite de 1000 termes ? Bien que l'algorithme soit efficace, la génération de milliers de termes peut solliciter la mémoire du navigateur, en particulier sur les appareils mobiles. En pratique, vous aurez rarement besoin de plus de 100-200 termes pour la plupart des analyses mathématiques ou des objectifs éducatifs.

Comprendre la Formule de la Séquence de Moser-de Bruijn

Vous pouvez définir la séquence de Moser-de Bruijn de trois manières équivalentes, chacune offrant des perspectives différentes :

Trois Façons de Définir la Séquence

Forme Additive (Puissances de 4) : Un nombre n appartient à la séquence lorsque vous pouvez l'écrire comme : $n = \sum_{i \in S} 4^i$ où S est n'importe quel ensemble d'entiers non négatifs. Chaque puissance de 4 peut apparaître une fois ou pas du tout — aucune répétition n'est autorisée.

Représentation en Base-4 (Test le Plus Simple) : Convertissez un nombre en base 4. Si vous ne voyez que des 0 et des 1 (pas de 2 ou de 3), il est dans la séquence. C'est le moyen le plus rapide de vérifier l'appartenance à la main.

Correspondance Binaire (Le Plus Utile pour le Calcul) : Pour trouver le n-ième terme (en commençant par n=0) : $M(n) = \sum_{i=0}^{k} b_i \cdot 4^i$ où $b_i$ sont les chiffres binaires de n. Traduction : Prenez la représentation binaire de votre index, puis remplacez chaque bit "1" par la puissance de 4 correspondante.

Exemples Pratiques

Voyons comment ces définitions fonctionnent :

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

La méthode de correspondance binaire est ce que ce générateur utilise sous le capot — elle est computationnellement efficace car les opérations bit à bit sont rapides.

Calcul de la Séquence de Moser-de Bruijn

L'Algorithme Derrière le Générateur

Le générateur utilise la correspondance binaire car elle est rapide et simple :

Processus Étape par Étape :

Parcourir chaque index i de 0 à n-1 (n est le nombre de termes demandés)
Pour l'index i, examiner sa représentation binaire
Pour chaque bit "1" à la position j, ajouter 4^j au total en cours
Cette somme devient le i-ème terme

Exemple Détaillé : Trouver le 6ème terme (index 5)

Calculons M(5) étape par étape :

Index 5 en binaire : 101
Bit 0 (le plus à droite) = 1 → ajouter 4⁰ = 1
Bit 1 (au milieu) = 0 → ne rien ajouter
Bit 2 (le plus à gauche) = 1 → ajouter 4² = 16
Résultat final : 1 + 16 = 17

Cette méthode s'adapte bien. Pour de grands indices, vous effectuez essentiellement des décalages de bits et des additions—des opérations que les processeurs modernes gèrent extrêmement rapidement.

Tester si un Nombre Appartient à la Séquence

Vous voulez vérifier si un nombre spécifique est dans la séquence de Moser-de Bruijn ? Utilisez le test en base 4 :

Convertir votre nombre en base 4
Parcourir les chiffres—ne voyez-vous que des 0 et des 1 ?
Si oui, il est dans la séquence. Si vous voyez un 2 ou un 3, il n'y est pas.

Exemple : 85 est-il dans la séquence ?

85 en base 4 : 1111 (c'est 64 + 16 + 4 + 1)
Contient uniquement des 1 → Oui, 85 est dans la séquence

Contre-exemple : 90 est-il dans la séquence ?

90 en base 4 : 1122
Contient le chiffre 2 → Non, 90 n'est pas dans la séquence

Le générateur implémente ceci en utilisant les opérateurs de bits de JavaScript, qui sont natifs au langage et hautement optimisés dans les navigateurs modernes.

Qu'en est-il des Unités et de la Précision ?

La séquence de Moser-de Bruijn traite des entiers purs :

Tous les termes sont des nombres entiers non négatifs (0, 1, 4, 5, 16, etc.)
Pas d'unités, de décimales ou d'arrondis
Les résultats sont mathématiquement exacts—vous obtenez des entiers précis à chaque fois
La croissance est exponentielle : le n-ième terme peut atteindre jusqu'à environ 4^(⌊log₂(n)⌋+1) - 1

Cette croissance exponentielle signifie que la séquence devient rapidement grande. Le 20ème terme est déjà 340, et au 100ème terme, vous traitez des nombres en millions.

Applications Réelles et Cas d'Utilisation

Éducation et Apprentissage

Enseignement des Systèmes de Numération : Lorsque j'ai utilisé cela dans des salles de classe, les étudiants comprennent beaucoup plus rapidement les conversions de base lorsqu'ils peuvent jouer avec la séquence de Moser-de Bruijn. Elle établit un pont entre le binaire (base 2) et des systèmes numéraux plus complexes. Les étudiants voient immédiatement comment le changement de base modifie la densité de la séquence.

Comprendre les Opérations Bit à Bit : Les étudiants en informatique bénéficient de voir la connexion directe entre la représentation binaire et les séquences mathématiques. L'algorithme démontre comment la manipulation de bits se traduit en objets mathématiques réels—et pas seulement en opérations abstraites.

Recherche et Analyse

Combinatoire et Ensembles Sans Somme : Les chercheurs étudiant les bases additives utilisent des séquences comme celle-ci pour explorer les ensembles permettant des représentations uniques. La séquence de Moser-de Bruijn est un exemple type d'un ensemble où chaque nombre représentable a exactement une représentation.

Théorie des Nombres Additifs : La séquence aide à investiguer les questions sur la façon dont les entiers peuvent être décomposés en sommes. Elle est liée aux problèmes de l'Encyclopédie en Ligne des Séquences d'Entiers (OEIS), où elle est répertoriée sous A000695.

Programmation Pratique

Conception d'Algorithmes : L'algorithme de génération montre une construction de séquence efficace. Vous pouvez générer des milliers de termes avec une surcharge computationnelle minimale, ce qui le rend utile pour le benchmarking d'algorithmes ou l'enseignement de modèles de code efficaces.

Tâches de Reconnaissance de Motifs : Lors du travail avec des ensembles d'entiers épars ou des schémas de compression de données, comprendre le comportement de séquences comme Moser-de Bruijn aide à éclairer les décisions de conception concernant les stratégies d'encodage.

Séquences Mathématiques Connexes

Si la séquence de Moser-de Bruijn vous intéresse, ces séquences connexes offrent des motifs similaires avec différentes bases ou contraintes :

Parents Directs

Puissances de 2 (OEIS A000079) : 1, 2, 4, 8, 16, 32... La base additive la plus simple. Chaque puissance de 2 apparaît exactement une fois, formant les blocs de construction des nombres binaires.

Tous les Entiers Non Négatifs (Sommes Binaires) : 0, 1, 2, 3, 4, 5, 6, 7... Lorsque vous autorisez toute somme de puissances de 2 distinctes, vous obtenez tous les entiers possibles—c'est ce que fait la représentation binaire.

Sommes de Puissances Distinctes de 3 (OEIS A005836) : 0, 1, 3, 4, 9, 10, 12, 13... Même concept que Moser-de Bruijn, mais en utilisant des puissances de 3 au lieu de 4. Ce sont des nombres dont la représentation en base 3 contient uniquement des 0 et des 1.

Variantes Intéressantes

Nombres Fibinaires (OEIS A003714) : 0, 1, 2, 4, 5, 8, 9, 10... Nombres dont la forme binaire n'a pas de 1 consécutifs. Liés aux systèmes de nombres de Fibonacci et au théorème de Zeckendorf.

Séquence de Stanley : L'analogue en base 3 de Moser-de Bruijn—nombres sans 1 dans leur représentation en base 3 (seuls les 0 et les 2 sont autorisés).

Où en Apprendre Plus

L'Encyclopédie en Ligne des Suites d'Entiers (OEIS) catalogue des centaines de milliers de séquences. Recherchez des termes comme « base additive », « ensemble sans somme » ou « puissances distinctes » pour trouver des séquences connexes. La séquence de Moser-de Bruijn elle-même est A000695 dans la base de données OEIS.

Contexte historique

Les Mathématiciens derrière la Séquence

Leo Moser (1921-1970) et Nicolaas Govert de Bruijn (1918-2012) ont tous deux apporté des contributions durables aux mathématiques, bien qu'ils proviennent de différents horizons. Moser, un mathématicien austro-canadien, a travaillé extensivement en théorie des nombres, combinatoire et géométrie—vous pourriez reconnaître son nom de l'équation d'Erdős–Moser. De Bruijn, un mathématicien néerlandais, a laissé son empreinte en combinatoire, théorie des graphes et informatique. Ses séquences de de Bruijn (différentes de celle-ci) sont fondamentales en théorie du codage et toujours largement utilisées aujourd'hui.

Leur séquence éponyme a émergé dans les années 1960 lors d'investigations en théorie additive des nombres. Les mathématiciens se posaient la question : quels ensembles d'entiers permettent de représenter uniquement d'autres entiers comme sommes ? Les puissances de 4 se sont avérées être un tel ensemble, et la séquence de Moser-de Bruijn capture toutes les sommes possibles que l'on peut construire.

Pourquoi Cela Importe

La séquence s'inscrit dans l'étude plus large des bases additives—ensembles d'entiers qui peuvent construire d'autres entiers par addition. Certaines bases permettent des représentations uniques (comme les puissances de 4), tandis que d'autres non. Comprendre les propriétés de ces bases reste un domaine de recherche actif en théorie additive des nombres.

Vous trouverez cette séquence sous A000695 dans l'OEIS, où les mathématiciens ont documenté ses connexions à la représentation binaire, aux systèmes quaternaires (base-4) et aux propriétés combinatoires. L'informatique moderne a trouvé de nouveaux usages, particulièrement dans les algorithmes impliquant la manipulation de bits et l'encodage efficace de structures de données creuses.

Exemples d'implémentation de code

Vous voulez implémenter vous-même le générateur de séquence de Moser-de Bruijn ? Voici des implémentations efficaces dans des langages de programmation populaires. Chaque exemple comprend à la fois un générateur de séquence et une fonction de test d'appartenance.

1def moser_de_bruijn(n):
2    """Générer les n premiers termes de la séquence de Moser-de Bruijn."""
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:  # Vérifier si le bit le moins significatif est 1
10                term += power
11            power *= 4
12            temp >>= 1  # Décalage à droite pour vérifier le bit suivant
13        sequence.append(term)
14    return sequence
15
16# Exemple d'utilisation :
17terms = moser_de_bruijn(20)
18print("Premiers 20 termes de la séquence de Moser-de Bruijn :")
19print(terms)
20# Sortie : [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    """Vérifier si un nombre est dans la séquence de Moser-de Bruijn."""
24    while num > 0:
25        digit = num % 4
26        if digit > 1:
27            return False
28        num //= 4
29    return True
30
31# Vérifier si 21 est dans la séquence
32print(f"21 est-il dans la séquence ? {is_moser_de_bruijn(21)}")  # Vrai
33print(f"22 est-il dans la séquence ? {is_moser_de_bruijn(22)}")  # Faux
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) {  // Vérifier si le bit le moins significatif est 1
9        term += power;
10      }
11      power *= 4;
12      temp >>= 1;  // Décalage à droite pour vérifier le bit suivant
13    }
14    sequence.push(term);
15  }
16  return sequence;
17}
18
19// Exemple d'utilisation :
20const terms = moserDeBruijn(20);
21console.log("Premiers 20 termes de la séquence de Moser-de Bruijn :");
22console.log(terms);
23// Sortie : [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// Vérifier des nombres spécifiques
37console.log(`21 est-il dans la séquence ? ${isMoserDeBruijn(21)}`);  // vrai
38console.log(`22 est-il dans la séquence ? ${isMoserDeBruijn(22)}`);  // faux
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) {  // Vérifier si le bit le moins significatif est 1
14                    term += power;
15                }
16                power *= 4;
17                temp >>= 1;  // Décalage à droite pour vérifier le bit suivant
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("Premiers 20 termes de la séquence de Moser-de Bruijn :");
38        System.out.println(terms);
39        
40        System.out.println("21 est-il dans la séquence ? " + isMoserDeBruijn(21));  // vrai
41        System.out.println("22 est-il dans la séquence ? " + isMoserDeBruijn(22));  // faux
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) {  // Vérifier si le bit le moins significatif est 1
12                term += power;
13            }
14            power *= 4;
15            temp >>= 1;  // Décalage à droite pour vérifier le bit suivant
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 << "Premiers 20 termes de la séquence de Moser-de Bruijn :" << std::endl;
36    for (int term : terms) {
37        std::cout << term << " ";
38    }
39    std::cout << std::endl;
40    
41    std::cout << "21 est-il dans la séquence ? " << (isMoserDeBruijn(21) ? "vrai" : "faux") << std::endl;
42    std::cout << "22 est-il dans la séquence ? " << (isMoserDeBruijn(22) ? "vrai" : "faux") << std::endl;
43    
44    return 0;
45}
46

Perspectives clés de l'implémentation

Toutes ces implémentations suivent le même modèle : utiliser des opérations bit à bit pour lire la représentation binaire d'un index, puis construire la somme correspondante des puissances de 4. Les fonctions de test d'appartenance utilisent l'approche en base 4 — en vérifiant si les chiffres sont limités à 0 et 1.

En termes de performances, ces implémentations sont très efficaces. La complexité temporelle est O(n × log n) pour générer n termes, car chaque terme nécessite l'examen de O(log i) bits. La vérification de l'appartenance pour un seul nombre est O(log N) où N est le nombre testé.

Exemples Numériques Détaillés

Le tableau ci-dessous montre les 32 premiers termes avec des décompositions complètes. Remarquez comment la représentation en base-4 contient uniquement des 0 et des 1, et comment la décomposition correspond directement aux indices binaires :

Index	Terme	Décomposition	Base-4
0	0	0	0
1	1	4⁰	1
2	4	4¹	10
3	5	4¹ + 4⁰	11
4	16	4²	100
5	17	4² + 4⁰	101
6	20	4² + 4¹	110
7	21	4² + 4¹ + 4⁰	111
8	64	4³	1000
9	65	4³ + 4⁰	1001
10	68	4³ + 4¹	1010
11	69	4³ + 4¹ + 4⁰	1011
12	80	4³ + 4²	1100
13	81	4³ + 4² + 4⁰	1101
14	84	4³ + 4² + 4¹	1110
15	85	4³ + 4² + 4¹ + 4⁰	1111
16	256	4⁴	10000
17	257	4⁴ + 4⁰	10001
18	260	4⁴ + 4¹	10010
19	261	4⁴ + 4¹ + 4⁰	10011
20	272	4⁴ + 4²	10100
21	273	4⁴ + 4² + 4⁰	10101
22	276	4⁴ + 4² + 4¹	10110
23	277	4⁴ + 4² + 4¹ + 4⁰	10111
24	320	4⁴ + 4³	11000
25	321	4⁴ + 4³ + 4⁰	11001
26	324	4⁴ + 4³ + 4¹	11010
27	325	4⁴ + 4³ + 4¹ + 4⁰	11011
28	336	4⁴ + 4³ + 4²	11100
29	337	4⁴ + 4³ + 4² + 4⁰	11101
30	340	4⁴ + 4³ + 4² + 4¹	11110
31	341	4⁴ + 4³ + 4² + 4¹ + 4⁰	11111

Regard Détaillé sur le Terme 21

Décomposons complètement le terme 21 :

Valeur décimale : 21
Représentation en base-4 : 111 (utilise uniquement 0 et 1 ✓)
Index dans la séquence : 7
Index binaire : 111 (binaire de 7)
Décomposition : 21 = 16 + 4 + 1 = 4² + 4¹ + 4⁰

Voyez-vous le modèle ? L'index binaire (111) correspond directement aux puissances de 4 à inclure. Chaque bit "1" vous indique d'inclure cette puissance.

Observer le Modèle de Croissance

La séquence croît exponentiellement—le n-ième terme est approximativement proportionnel à 4^(log₂(n)). Que signifie cela pratiquement ?

Au terme 10, vous êtes à 68
Au terme 20, vous atteignez 272
Au terme 100, vous êtes dans les millions

Au fur et à mesure que les nombres deviennent plus grands, la séquence devient de plus en plus clairsemée. Vous sautez de plus en plus d'entiers. Malgré cette dispersion, la séquence contient une infinité de termes—elle ne cesse jamais de croître.

Références et lectures complémentaires

Sources primaires

OEIS A000695 - Séquence de Moser-de Bruijn. L'Encyclopédie en ligne des suites d'entiers. Données et propriétés complètes de la séquence.
De Bruijn, N. G. "Sur les bases de l'ensemble des entiers." Publicationes Mathematicae Debrecen, vol. 1, 1950, pp. 232-242. L'article fondateur établissant les propriétés clés des bases additives.
Moser, Leo. "Une application des séries génératrices." Mathematics Magazine, vol. 35, no. 1, 1962, pp. 37-38. Travail précoce explorant les fonctions génératrices de la séquence.

Contexte mathématique supplémentaire

Stolarsky, Kenneth B. "Sommes de puissances et d'exponentielles des sommes digitales liées à la parité des coefficients binomiaux." SIAM Journal on Applied Mathematics, vol. 32, no. 4, 1977, pp. 717-730. Explore les propriétés des sommes digitales liées aux séquences comme Moser-de Bruijn.
Allouche, Jean-Paul, et Jeffrey Shallit. Séquences automatiques : Théorie, Applications, Généralisations. Cambridge University Press, 2003. Chapitre traitant des séquences automatiques, y compris les connexions avec la séquence de Moser-de Bruijn.

Concepts connexes

Ensembles sans somme - Wikipédia. Contexte général de la théorie des nombres additifs.
Bases additives - Wikipédia. Vue d'ensemble des ensembles pouvant représenter des entiers comme des sommes.

Questions fréquemment posées

À quoi sert la séquence de Moser-de Bruijn ?

La séquence a plusieurs applications : recherche en théorie des nombres explorant les bases additives, travaux de combinatoire sur les ensembles sans somme, enseignement en informatique (en particulier pour l'enseignement des opérations bit à bit et des algorithmes efficaces), et analyse de motifs mathématiques. C'est aussi un excellent outil pédagogique pour comprendre comment différentes bases numériques sont liées entre elles.

Comment générer la séquence de Moser-de Bruijn ?

Prenez chaque index n à partir de 0, convertissez-le en binaire, puis remplacez chaque bit "1" par la puissance de 4 correspondante. Par exemple, l'index 5 a une représentation binaire 101, donc vous calculez 4² + 4⁰ = 16 + 1 = 17. C'est le 5ème terme (en comptant à partir de l'index 0).

Qu'est-ce qui rend la séquence de Moser-de Bruijn spéciale ?

Chaque nombre de la séquence a une propriété distinctive : sa représentation en base 4 contient uniquement des 0 et des 1 — jamais de 2 ou de 3. Cela signifie que vous pouvez construire chaque terme en additionnant des puissances de 4 où chaque puissance apparaît au maximum une fois. C'est comme le binaire, mais en utilisant des puissances de 4 au lieu de puissances de 2.

Comment puis-je vérifier si un nombre spécifique est dans la séquence ?

Convertissez votre nombre en base 4 et regardez les chiffres. S'il n'y a que des 0 et des 1, il est dans la séquence. Si un chiffre est 2 ou 3, il n'y est pas. Par exemple, 21 en base 4 est 111 (tous des 1 et des 0), donc il est dedans. Mais 22 en base 4 est 112 (contient un 2), donc il n'y est pas.

Quelle est la formule pour le nième terme ?

Le n-ième terme M(n) suit cette formule : M(n) = Σ(b_i × 4^i), où b_i représente les chiffres binaires de n. En langage simple : écrivez n en binaire, puis pour chaque position avec un 1, ajoutez la puissance de 4 correspondante.

La séquence est-elle infinie ?

Oui, elle continue indéfiniment. Il y a une infinité de termes dans la séquence de Moser-de Bruijn. Cependant, plus vous montez, plus la séquence devient clairsemée — vous sautez de plus en plus d'entiers réguliers entre les membres de la séquence.

En quoi diffère-t-elle des séquences binaires ?

Les séquences binaires (sommes de puissances de 2) peuvent représenter tous les entiers non négatifs — c'est ce que fait la représentation binaire. La séquence de Moser-de Bruijn utilise des puissances de 4 à la place, ce qui crée un ensemble beaucoup plus clairsemé. La plupart des entiers n'apparaissent pas dans la séquence de Moser-de Bruijn.

Qui a découvert cette séquence ?

Leo Moser (1921-1970), un mathématicien austro-canadien, et Nicolaas Govert de Bruijn (1918-2012), un mathématicien néerlandais, ont tous deux étudié cette séquence en profondeur dans les années 1960 dans le cadre de recherches sur la théorie additive des nombres. La séquence porte les noms des deux.

Prêt à Explorer ?

Ce générateur fonctionne entièrement dans votre navigateur — pas d'installation, pas d'inscription, pas d'attente. Que vous soyez un étudiant qui apprend les systèmes numériques, un chercheur explorant les bases additives, ou simplement curieux mathématiquement, vous pouvez générer des termes instantanément et observer vous-même les modèles. Essayez de générer différentes quantités pour voir comment la séquence se développe et quels entiers sont inclus.

Générateur de Séquence de Moser-de Bruijn | Calculateur de Puissances de 4

Séquence Générée

Documentation