Enigmatus, c'est une première réponse à minima. Mais je n'aurais pas proposé cette question si la réponse était réduite à m+1 codes différents sur m bits.

On peut faire mieux.

Exemple:

Je code sur m bits:
-tous les codes à 2 bits à 1 décalés de 2 unités (..101...)
-tous les codes à 2 bits à 1 décalés de 3 unités (...1001..)
-tous les codes à 2 bits à 1 décalés de 7 unités (..10000001...)
De plus, je dispose les m bits sur un cercle, de sorte que je peux mettre m codes pour chaque catégorie.

Normalement la superposition permet de tjs distinguer les 2 codes.

Pour m=20  (il faut un minimum de bits) par exemple , je peux faire 60 codes différents.

Et du coup, en reprenant l'exemple que tu donnes, il y a un lien clair entre les nombres 2, 3, 7 etc... et le problème précédent.
4=2+2, 5=2+3, 6=3+3 ne sont pas retenus. 7, oui.
8+2 = 7+3, 9 = 7+2, 10=7+3, 11+3=7+7, 12+2 = 7+7
(Explication pour 8, 11 et 12, avec comme exemple 11: 100010010001 est à la fois la superposition d'un bloc "décalage 11" et d'un bloc "décalage 3" par dessus, ou 2 blocs "décalage 7" qui se chevauchent)
J'imagine que le suivant sera donc un bloc "décalage 13", puis 21, 30, 45, 61, 81, 107, 136

Bien vu, Scarta, je n'avais pas vraiment fait le rapprochement de cette façon avec le message précédent. Cependant, il faut bien avoir en tête que l'exemple que j'ai présenté reste un exemple, et il faut bien admettre que le nombre de codes reste bien faible par rapport aux possibilités offertes. Il y a une infinité de manières d'aborder ce problème, alors il faut les inventer.
J'ai pour ma part une autre idée de codage totalement différente, et qui semble être bien plus efficace, mais elle est encore à vérifier.

Damned, il a raison
En fait ça ne marche jamais, c'est pas les blocs avec des décalages de 2 ou de 3 qui coincent. Pour deux décalages distincts m et n, m<n, si j'écris 1+(m-1)0+1+(n-m-1)0+1+(m-1)0+1, alors j'ai deux manière d'obtenir ce résultat : via deux blocs de taille (m+1), qui sont lu tels quels, et deux blocs de taille (n+1) qui se chevauchent.

J'avais pris ton affirmation pour argent comptant et j'étais parti sur une analyse de la suite. Du coup, tout le reste du raisonnement est faux.

Bon, j'expose ici mon idée, j'espère qu'elle peut être mise dans un programme facilement....

Je réserve un certain nombre de bits à une opération de codage, comme on fait en transmission pour sécuriser les messages. Le reste des bits est rempli par le nombre proprement dit écrit en binaire.

Codage:
On associe à un nombre donné sa valeur modulo un ou plusieurs nombres impairs (j'avais pensé modulo un nombre premier autre que 2, mais impair devrait convenir).
On réserve pour ce reste autant de bits que de restes possibles:
3 bits pour modulo 3 (0,1,2)
5 bits pour modulo 5 (0,1,2,3,4)
k bits pour modulo k. (0,1,2,..k-1)

Un bit est à 1 pour la valeur modulo le nombre.

Plus on choisit de nb modulo, plus on va occuper des bits. Si on veut utiliser 3 et 5, il faut 8 bits. Si on veut utiliser 3,5 et 7, il faut 15 bits. etc...

Le nombre de modulos à utiliser est donc en rapport avec l'efficacité qu'on peut en tirer. Plus on veut obtenir de nombres, plus on aura besoin de modulos.
Pour l'instant, je n'ai pas d'idée sur la performance à attendre, seuls des essais pourront le dire.

Pour attteindre 1000 nombres par exemple, je vois ça comme ça:
bits 1 à 3 pour le reste modulo 3
bits 4 à 8 pour le reste modulo 5
bits 9 à 15 pour le reste modulo 7
bits 16 à 24 pour le reste modulo 9

Compte tenu des déchets inévitables à attendre, je vois environ 15 bits nécessaires pour obtenir les 1000 chiffres.

Quelqu'un pour se pencher sur le programme qui en découle ?

Il n'est pas facile, puisqu'il faut déja inventer l'opération de superposition, faire des opérations en binaire, etc....

En revanche, on peut le faire tourner en prenant les entiers dans l'ordre, comme dans le problème précédent.

J'espère que c'est assez clair.

Avec la configuration de codage 3,5,7,9, le nombre 758 par exemple va s'écrire ainsi:
001 car son reste modulo 3 vaut 2.
00010 car son reste modulo 5 vaut 3
00100000 car son reste modulo 7 vaut 2
001000000 car son reste modulo 9 vaut 2
1011110110 pour 758 écrit en binaire.

Le code complet de 758 est donc :
001.00010.0010000.001000000.1011110110

il n'est pas certain qu'il faille 19 chiffres binaires, car il faut tenir compte des bits de codage.

Qu'il y ait des sommes identiques, c'est normal, on ne peut pas l'éviter. Ce qui est important, c'est de connaitre le taux de déchet. J'imagine bien que ce taux augmente avec le nombre de 1 dans le nombre binaire.
As tu déja mis au point un algo ?
De plus, il faut faire tourner la routine sur plus que 999 si on veut espérer obtenir 1000 gagnants.

67% des nombres compris entre 0 et 999, ça fait dans les 670 nombres corrects ?
Si c'est bien ça, je prends tout de suite !

Est ce que ça a pris beaucoup de temps ?

Est ce que tu peux prolonger jusqu'à obtenir les 1000 nombres corrects ?

Normalement, c'est quand il y a beaucoup de 1 dans le nombre binaire qu'on a le plus de chance d'échec. J'avais idée au départ de procéder en prenant tous les nombres à 1 seul bit à 1, puis tous les nombres à 2 bits à 1, puis tous les nombres à 3 bits à 1, etc....Mais, au dela de la complexité supplémentaire, on est obligé au départ de fixer un nombre de bits donné. On arrive sans doute plus vite au résultat, mais il faut faire plusieurs essais. Aussi, je m'en suis tenu au test des nombres dans l'ordre naturel. ça permet d'avoir une vision sur l'efficacité de la méthode. Pour l'instant, j'en suis agréablement surpris.
Et merci pour ton travail !

Ah d'accord, ça me semblait trop beau.

J'ai trouvé pareil, et ça a confirmé quelques résultats intéressants:
- pour toute permutation des n bits, on trouvera un autre ensemble - facile à démontrer
- le premier ensemble optimal (> n+1 éléments) ne peut pas contenir 0 et une puissance de 2 : d'après le point précédent, c'est équivalent à contenir 0 et 1, tout nombre impair donnera le même résultat avec 0 ou 1, donc tous les autres sont pairs et par conséquent il y a autant d'éléments que dans un ensemble pour n'=n-1, avec un zéro pour dernier bit, plus le nombre 1

Le fait qu'il y ait 120 ensembles est intéressant, il faudrait les normaliser pour voir de combien de permutations initiales ils sont issus.

J'ai une solution, inspirée des modulos, mais plus simple, et pour celle ci je prouve que ça marche :
Pour un segment de 2n bits, on réserve les bits numérotés 1 à n au codage (c'est la zone codage )  les n autres bits, également numérotés de 1 à n, sont utilisés pour le nombre binaire.
Les nombres binaires se limitent à 2 bits à 1. On peut TOUS les utiliser. Le codage consiste à faire la somme modulo n des 2 bits de chaque nombre binaire.

Exemple :
Le nombre binaire est représenté par un bit au rang 2 et un bit au rang 4 : codage : 2+4=6, donc un bit à 1 au rang 6 de la zone codage.

Preuve:
On prouve que la superposition est toujours décomposable.
Une superposition, c'est 3 bits à 1 ou 4 bits à 1 :

si 3 bits à 1 aux rangs a < b < c.
Les sommes a+b, a+c et b+c sont distinctes
Preuve
on suppose a+b=x et b+c=x+n la différence vaut c-a=n impossible.
Le codage fait donc distinguer les 2 nombres.


Si 4 bits à 1 aux rangs a < b < c < d
Les égalités possibles sont :
a+b=c+d [n] ou a+d=b+c  mais pas en même temps. S'il existe une des égalités, alors un seul bit à 1 dans la zone codage, qui correspond à a+b ou a+d.
Si pas d'égalité, on cherche la somme qui convient avec a + (b ou c ou d).


Performance:
Dans 2n bits, on peut placer n(n-1)/2 nombres.

NB: on peut adjoindre les nombres à 1 bit, sauf 1, ce qui augmente légèrement la performance.

Oui, Enigmatus, erreur en rédigeant. correction faite.

Voici ce que ça donne avec n=5, le 1er nombre est le nombre binaire défini par le rang de ses 2 bits, le second est le code défini par le rang de la somme des 2 rangs du nombre, modulo 5:

12-3
13-4: somme 123-34
14-5: sommes 124-35; 134-45
15-1: sommes 125-13; 135-14; 145-15
23-5: sommes 123-35; 123-45; 1234-5; 1235-15
24-1: sommes 124-13; 1234-14; 124-15; 1245-1; 234-15
25-2: sommes 125-23; 1235-24; 1245-25; 125-12; 235-25; 245-12
34-2: sommes 1234-23; 134-24; 134-25; 1345-12; 234-25; 234-12; 2345-2
35-3: sommes 1235-3; 135-34; 1345-35; 135-13; 235-35; 2345-13; 235-23; 345-23
45-4: sommes 1245-34; 1345-4; 145-45; 145-14; 2345-45; 245-14; 245-24; 345-24; 345-34

Voila.
Mais cet exemple ne prouve pas que ça marche en généralisant. Il faut prouver que pour une superposition, on arrive à retrouver les 2 nombres grace au codage. Ce que je crois avoir fait.

On arrive ici à 10 nombres avec 10 bits, mais bien sûr le score s'améliore avec le nombre de bits.
Pour 92 bits: 1035 nombres.