Description des questions
Veuillez vérifier si le format de l'e-mail est légal en fonction de l'expression régulière donnée. Si le format saisi par l'utilisateur est légal, "Le format de l'e-mail est légal" sera affiché, sinon "Le format de l'e-mail est illégal" sera affiché. L'expression régulière correspondant au format correct est "[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9]+"; entrée : 123123
@
nowcoder Sortie .com
:
le format de courrier électronique est légal
analyser
La chose la plus simple à laquelle penser est la bibliothèque d'expressions régulières, qui peut être résolue directement. Bien sûr, c'est aussi la méthode utilisée dans le développement.
En tant que sujet d'algorithme et d'apprentissage d'algorithme, nous pouvons utiliser un algorithme couramment utilisé, une machine à états finis .
L'utilisation de cet algorithme me permet de déterminer logiquement et clairement si une chaîne est conforme à une certaine spécification. L'inconvénient est que la quantité de code est importante.
Mais c’est certainement une bonne idée qui peut nous aider à écrire des algorithmes logiquement corrects.
Contexte de l'algorithme
L'algorithme de machine à états finis (FSM) est un modèle mathématique utilisé pour décrire la transition d'un système entre une série d'états. Il se compose d'un ensemble d'états, d'événements d'entrée et d'événements de sortie. Les caractéristiques de l'algorithme FSM sont les suivantes :
Déterministe : l'algorithme FSM effectue toujours les transitions d'état dans le même ordre à partir d'une entrée. Cela signifie que l’algorithme FSM est déterministe, c’est-à-dire que pour la même entrée, il produit toujours la même sortie.
Directionnalité : chaque transition d'état dans l'algorithme FSM a une direction claire, c'est-à-dire qu'elle ne peut passer que de l'état actuel à l'état suivant. Cela permet à l'algorithme FSM de gérer efficacement des problèmes complexes tout en évitant la possibilité de boucles infinies.
Stockage simple : l'algorithme FSM n'a besoin de stocker que l'état actuel et un ensemble de règles de transformation, ses besoins en stockage sont donc relativement faibles. Cela rend l'algorithme FSM adapté aux situations de ressources limitées.
Évolutivité : l'algorithme FSM peut être étendu en ajoutant de nouveaux états et règles de transition pour gérer des problèmes plus complexes. Cela rend l'algorithme FSM très évolutif.
Facile à comprendre et à mettre en œuvre : La structure de l’algorithme FSM est simple et facile à comprendre et à mettre en œuvre. Cela rend l’algorithme FSM adapté à la résolution de problèmes dans divers domaines.
Les problèmes résolus par les algorithmes de machines à états finis comprennent :
Détection de séquence : l'algorithme FSM peut être utilisé pour détecter si une séquence répond à des conditions spécifiques, telles que détecter si une chaîne est une date valide, détecter si une séquence numérique est un nombre premier, etc.
Reconnaissance de formes : les algorithmes FSM peuvent être utilisés pour identifier des modèles spécifiques dans du texte, des images ou d'autres données, telles que l'identification d'adresses e-mail, la reconnaissance de chiffres manuscrits, etc.
Logique de contrôle : l'algorithme FSM peut être utilisé pour mettre en œuvre une logique de contrôle simple, telle que le contrôle de haut en bas de l'ascenseur, le contrôle du système d'éclairage domestique, etc.
Contrôle du matériel informatique : l'algorithme FSM peut être utilisé pour contrôler le matériel informatique, tel que le clavier, la souris et d'autres périphériques.
IA de jeu : l'algorithme FSM peut être utilisé pour implémenter une IA de jeu simple, telle que des jeux de société, des jeux de labyrinthe, etc.
le code
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
static boolean checkCharType(char c){
if(c>='a'&&c<='z' || c>='A'&&c<='Z' || c>='0'&&c<='9'){
return true;
}else{
return false;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
String emailMatcher="[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+";
// //write your code here......
// Pattern pattern=Pattern.compile(emailMatcher);
// if(pattern.matcher(str).matches()){
// System.out.println("邮箱格式合法");
// }else{
// System.out.println("邮箱格式不合法");
// }
/*
0:初始
1：123123
2：@
3：nowcoder
4: .
5: com
*/
int status=0;
for(int i=0;i<str.length();++i){
char c=str.charAt(i);
if(status==0){
if(checkCharType(c)){
status=1;
}else{
break;
}
}else if(status==1){
if(checkCharType(c)){
continue;
}else if(c=='@'){
status=2;
}else{
break;
}
}else if(status==2){
if(checkCharType(c)){
status=3;
}else{
break;
}
}else if(status==3){
if(checkCharType(c)){
continue;
}else if(c=='.'){
status=4;
}else{
break;
}
}else if(status==4){
if(checkCharType(c)){
status=5;
}else{
break;
}
}else if(status==5){
if(checkCharType(c)){
continue;
}else{
status=-1;
break;
}
}
}
if(status==5){
System.out.println("邮箱格式合法");
}else{
System.out.println("邮箱格式不合法");
}
}
}