Design DFA acceptant les chaînes binaires divisibles par un nombre 'n'
Je dois apprendre à concevoir un DFA tel que, quel que soit le nombre "n", il accepte les chaînes binaires {0, 1} dont le nombre décimal équivalent est divisible par "n".
Il y aura différents DFA pour différents 'n', mais quelqu'un peut-il donner une approche de base que je devrais suivre pour procéder avec un nombre quelconque de 0 <n <10.
Je sais que je suis assez en retard, mais je voulais juste ajouter quelques éléments à la réponse déjà correcte fournie par @Grijesh. Je voudrais juste souligner que la réponse fournie par @Grijesh ne produit pas le DFA minimal. Bien que la solution soit certainement la bonne façon d’obtenir un DFA, si vous avez besoin du DFA minimal, vous devrez examiner votre diviseur.
Comme par exemple dans les nombres binaires, si le diviseur est une puissance de 2 (c'est-à-dire 2 ^ n), le nombre minimal d'états requis sera n + 1. Comment concevriez-vous un tel automate? Il suffit de voir les propriétés des nombres binaires. Pour un nombre, disons 8 (ce qui correspond à 2 ^ 3), tous ses multiples auront les 3 derniers bits sous forme de 0. Par exemple, 40 en binaire est 101000. Par conséquent, pour qu'une langue accepte tout nombre divisible par 8, nous avons simplement besoin d'un automate qui voit si les 3 derniers bits sont 0, ce qui peut être fait dans seulement 4 états au lieu de 8 états. C'est la moitié de la complexité de la machine.
En fait, cela peut être étendu à n'importe quelle base. Pour un système de nombres de base ternaire, si, par exemple, nous devons concevoir un automate pour la divisibilité avec 9, nous devons simplement voir si les 2 derniers chiffres de l'entrée sont 0. Ce qui peut encore être fait dans seulement 3 états.
Bien que si le diviseur ne soit pas si spécial, alors nous devons examiner uniquement la réponse de @ Grijesh. Comme par exemple, dans un système binaire, si nous prenons les diviseurs de 3, 7 ou peut-être 21, nous n'aurons besoin que de ce nombre d'états. Donc, pour tout nombre impair n dans un système binaire, nous avons besoin de n états pour définir le langage qui accepte tous les multiples de n. D'autre part, si le nombre est pair mais pas une puissance de 2 (seulement dans le cas de nombres binaires), nous devons diviser le nombre par 2 jusqu'à ce que nous obtenions un nombre impair, puis nous pouvons trouver le nombre minimal d'états par en ajoutant le nombre impair produit et le nombre de fois que nous avons divisé par 2.
Par exemple, si nous devons trouver le nombre minimum d'états d'un DFA qui accepte tous les nombres binaires divisibles par 20, nous faisons:
20/2 = 10
10/2 = 5
Par conséquent, notre réponse est 5 + 1 + 1 = 7. (Le 1 + 1 parce que nous avons divisé le nombre 20 deux fois).
Vous pouvez construire DFA en utilisant de simples arithmétiques modulaires . Nous pouvons interpréter w qui est une chaîne de nombres k-ary en utilisant la règle suivante
V[0] = 0
V[i] = (S[i-1] * k) + to_number(str[i])
V[|w|] est un nombre que w représente. Si vous modifiez cette règle pour trouver w mod N, la règle devient ceci.
V[0] = 0
V[i] = ((S[i-1] * k) + to_number(str[i])) mod N
et chaque V[i] est l'un d'un nombre compris entre 0 et N-1, ce qui correspond à chaque état dans DFA. Nous pouvons utiliser cela comme transition d'état.
Voir un exemple.
k = 2, N = 5
| V | (V*2 + 0) mod 5 | (V*2 + 1) mod 5 |
+---+---------------------+---------------------+
| 0 | (0*2 + 0) mod 5 = 0 | (0*2 + 1) mod 5 = 1 |
| 1 | (1*2 + 0) mod 5 = 2 | (1*2 + 1) mod 5 = 3 |
| 2 | (2*2 + 0) mod 5 = 4 | (2*2 + 1) mod 5 = 0 |
| 3 | (3*2 + 0) mod 5 = 1 | (3*2 + 1) mod 5 = 2 |
| 4 | (4*2 + 0) mod 5 = 3 | (4*2 + 1) mod 5 = 4 |
k = 3, N = 5
| V | 0 | 1 | 2 |
+---+---+---+---+
| 0 | 0 | 1 | 2 |
| 1 | 3 | 4 | 0 |
| 2 | 1 | 2 | 3 |
| 3 | 4 | 0 | 1 |
| 4 | 2 | 3 | 4 |
Vous pouvez maintenant voir un modèle très simple. Vous pouvez réellement créer une transition DFA en écrivant simplement des nombres répétés de gauche à droite, de haut en bas, de 0 à N-1.