Finite State Automaton

In this challenge, you will implement a finite state automaton (FSA) to recognize a specific pattern in a sequence of characters.

What is a Finite State Automaton?

A finite state automaton is a mathematical model of computation used to design both computer programs and sequential logic circuits. It is a powerful tool for pattern matching as it consists of a finite number of states and transitions between these states based on input symbols.

Finite state automatons are widely used in text processing, lexical analysis, and many other areas where pattern recognition is essential.

Your Task

You need to create an FSA that can recognize the pattern "ab*c", where:

'a' is followed by zero or more **'b'**s and then followed by 'c'.

You will implement a function recognize_pattern that takes a string slice as input and returns a boolean indicating whether the input string matches the pattern.

Requirements

Implement the finite state automaton using Rust's enums and the match statement.
The function should handle empty strings and any invalid input gracefully.
Your FSA should consist of states and transitions implemented as Rust enums and functions.
You must handle state transitions explicitly using the match statement.

Example

let result = recognize_pattern("abbbc");
assert_eq!(result, true);
 
let result = recognize_pattern("ac");
assert_eq!(result, true);
 
let result = recognize_pattern("abbbd");
assert_eq!(result, false);
 
let result = recognize_pattern("");
assert_eq!(result, false);

Did You Know?

Finite state automatons have a wide range of applications outside computer science as well. For example, they are used in the design of digital circuits. In digital circuit design, an FSA can be used to create sequential circuits such as counters and communication protocol controllers. FSAs are also used in the field of linguistics to model the morphology of languages and in robotics to control the behavior of autonomous robots.

Hints

Think about how you can represent states and transitions using Rust enums.
Carefully plan the transitions between states based on the input characters.
Make sure to handle edge cases, such as an empty input string or invalid characters.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Ramon Silva

rsilva1

9 minutes ago

3.47ms

89.76kb

#[derive(PartialEq, Copy, Clone)]
enum State {
    Source,
    A,
    B,
    C,
    Sink,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state: State = State::Source;
    for ch in input.chars() {
        state = match (state, ch) {
            (State::Source, 'a') => State::A,
            (State::A, 'b') => State::B,
            (State::A, 'c') => State::C,
            (State::B, 'b') => State::B,
            (State::B, 'c') => State::C,
            _ => State::Sink,
        }
    }
    state == State::C
}

Holly Gent

PointlessParrot

2 hours ago

3.27ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    let mut state: State = State::State1; 
    
    for input_char in input.chars() {
        state = match change_state(state, input_char) {
            Some(s) => s,
            None => { return false; }, 
        }
    }
    match state {
        State::State3 => true,
        _ => false,
    }
}
fn change_state(current_state: State, input: char) -> Option<State> {
    match current_state {
        State::State1 => match input {
            'a' => Some(State::State2),
            _ => None,
        },
        
        State::State2 => match input {
            'b' => Some(State::State2),
            'c' => Some(State::State3),
            _ => None,
        },
        _ => None,
    }
}
enum State{
    State1,
    State2,
    State3,
}

miel-codeai

4 days ago

3.24ms

89.76kb

enum State {
    Start,
    SawA,
    Accept,
    Reject,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut current_state = State::Start;
    for c in input.chars() {
        current_state = match current_state {
            State::Start => match c {
                'a' => State::SawA,
                _ => State::Reject,
            },
            State::SawA => match c {
                'b' => State::SawA,
                'c' => State::Accept,
                _ => State::Reject,
            },
            State::Accept => State::Reject,
            State::Reject => State::Reject,
        };
    }
    match current_state {
        State::Accept => true,
        _ => false,
    }
}

Asrul Firdaus

AsrulF

7 days ago

3.24ms

89.76kb

pub enum State {
    Input,
    MiddleA,
    MiddleB,
    Finish
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    if input.is_empty() {
        return false;
    }
    if !input.is_ascii() {
        return false;
    }
    let mut state = State::Input;
    for ch in input.chars() {
        state = match (state, ch) {
            (State::Input, 'a') => State::MiddleA,
            (State::MiddleA, 'b') => State::MiddleB,
            (State::MiddleA, 'c') => State::Finish,
            (State::MiddleB, 'b') => State::MiddleB,
            (State::MiddleB, 'c') => State::Finish,
            _ => return false
        }
    }
    matches!(state, State::Finish)
}

<YoungAncient/>

youngancient

7 days ago

4.29ms

89.76kb

#[derive(PartialEq)]
pub enum States{
    Start,
    SawA,
    SawB,
    Accept,
    Reject
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut current_state = States::Start;
    for character in input.chars(){
        current_state = match (current_state,character){
            (States::Start,'a') => States::SawA,
            (States::SawA,'a') => States::Reject,
            (States::SawA,'b') => States::SawB,
            (States::SawA,'c') => States::Accept,
            (States::SawB,'b') => States::SawB,
            (States::SawB,'c') => States::Accept,
            _ => States::Reject
        }
    }
    return current_state == States::Accept
}

makinpaper

8 days ago

3.87ms

89.76kb

#[derive(PartialEq, Debug)]
enum State {
    Start,
    A,
    B,
    C,
}
pub fn recognize_pattern(input: &str) -> bool {
    let result = input
        .chars()
        .try_fold(State::Start, |acc, c| match (acc, c) {
            (State::Start, 'a') => Ok(State::A),
            (State::A, 'b') => Ok(State::B),
            (State::A, 'c') => Ok(State::C),
            (State::B, 'b') => Ok(State::B),
            (State::B, 'c') => Ok(State::C),
            _ => Err(()),
        });
    result == Ok(State::C)
}

Anton

majesty-dump

9 days ago

17.08ms

89.32kb

#[derive(PartialEq)]
enum FiniteState {
    A,
    B,
    C,
}
impl FiniteState {
    pub fn from_char(c : char) -> Result<FiniteState, String> {
        match c {
            'a' => Ok(FiniteState::A),
            'b' => Ok(FiniteState::B),
            'c' => Ok(FiniteState::C),
            _ => Err("Bad state".to_string()),
        }
    }
    pub fn process_transition(self, new_state : FiniteState) -> Result<FiniteState, String> {
        match (self, new_state) {
            (FiniteState::A, FiniteState::B) => Ok(FiniteState::B),
            (FiniteState::A, FiniteState::C) => Ok(FiniteState::C),
            (FiniteState::B, FiniteState::B) => Ok(FiniteState::B),
            (FiniteState::B, FiniteState::C) => Ok(FiniteState::C),
            _ => Err("Wrong transition".to_string())
            
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    if input.len() == 0 {
        return false;
    }
    let mut current_state : FiniteState = FiniteState::from_char(input.chars().nth(0).unwrap()).expect("Reason : ");
    if current_state != FiniteState::A {
        return false;
    }
    for i in 1..input.len() {
        match FiniteState::from_char(input.chars().nth(i).unwrap()) {
            Ok(new_state) => {
                if let Ok(updated_state) = current_state.process_transition(new_state) {
                    current_state = updated_state;
                } else {
                    return false;
                }
                
            },
            Err(_) => {
                return false;
            }
        }
    }
if current_state != FiniteState::C {
    return false;
}
    return true;
}

Josh Willing

jwillinghalpern

12 days ago

3.29ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    if input.len() < 2 {
        return false;
    }
    let bytes = input.as_bytes();
    if bytes.get(0) != Some(&b'a') {
        return false;
    }
    if bytes.last() != Some(&b'c') {
        return false;
    }
    let middle = &bytes[1..bytes.len() - 1];
    for &byte in middle {
        if byte != b'b' {
            return false;
        }
    }
    true
}

Kishan

wdcs-kishansudani

15 days ago

3.46ms

89.76kb

#[derive(Debug, PartialEq, Eq)]
enum PatternState {
    Start, // expecting 'a'
    A,     // after 'a', zero or more 'b'
    B,     // after 'c'
    C,
    Invalid,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = PatternState::Start;
    for c in input.chars() {
        state = match (c, state) {
            ('a', PatternState::Start) => PatternState::A,
            ('b', PatternState::A) => PatternState::B,
            ('c', PatternState::A) => PatternState::C,
            ('b', PatternState::B) => PatternState::B,
            ('c', PatternState::B) => PatternState::C,
            _ => PatternState::Invalid,
        };
        if let PatternState::Invalid = state {
            return false;
        }
    }
    state == PatternState::C
}

Sheren Yogesh Narayanan

Nsy97

17 days ago

4.68ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    
    let mut state = State::Start;
    for ch in input.chars() {
        state = match (state, ch) {
            (State::Start, 'a') => State::Sa,
            (State::Sa, 'b') => State::Sb,
            (State::Sb, 'b') => State::Sb,
            (State::Sb, 'c') => State::Accept,
            (State::Sa, 'c') => State::Accept,
            _ => State::Reject
        };
    } 
    if state == State::Accept {
        true
    }
    else {
        false
    }
}
#[derive(Debug, PartialEq)]
enum State {
    Start,
    Sa,
    Sb,
    Sc,
    Accept,
    Reject
}

Vincent SAMY

vsamy

a month ago

3.55ms

89.76kb

#[derive(Debug, PartialEq, Clone, Copy)]
enum State {
    Init,
    SearchBs,
    End,
    Invalid
}
impl State {
    fn process(&mut self, c: char) {
        use State::*;
        *self = match (*self, c) {
            (Init, 'a') => SearchBs,
            (SearchBs, 'b') => *self,
            (SearchBs, 'c') => End,
            (_, _) => Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Init;
    for c in input.chars() {
        state.process(c);
    }
    state == State::End
}

Splatrac

splatrac

2 months ago

3.27ms

89.76kb

#[derive(PartialEq, Clone, Copy)]
enum State {
    Idle,
    Processing,
    Finished,  
}
impl State {
    fn next_state(self) -> State {
        match self {
            State::Idle => State::Processing,
            State::Processing => State::Finished, 
            State::Finished => State::Idle, 
        }
    } 
    fn process(&mut self, input: char) {
        *self = match (*self, input) {
            (State::Idle, 'a') => self.next_state(),
            (State::Processing, 'b') => *self,
            (State::Processing, 'c') => self.next_state(),
            _ => State::Idle,
        };
    } 
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state = State::Idle;
    for c in input.chars() {
        state.process(c);
    }
    state == State::Finished
}

Prakash Mardi

Mardiprk

2 months ago

3.23ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    let mut state = 0;
    for ch in input.chars() {
        state = match state {
            0 => {
                if ch == 'a' {
                    1
                } else {
                    return false;
                }
            }
            1 => {
                if ch == 'b' {
                    1 
                } else if ch == 'c' {
                    2 
                } else {
                    return false;
                }
            }
            2 => {
                return false;
            }
            _ => unreachable!(),
        }
    }
    state == 2
}

Dominic Chua

DeusSeos

2 months ago

3.25ms

89.76kb

#[derive(Debug, PartialEq, Eq)]
enum PatternState {
    Start,     // expecting 'a'
    InBs,      // after 'a', zero or more 'b'
    End,       // after 'c'
    Invalid,   // any unexpected char
}
pub fn recognize_pattern(input: &str) -> bool {
    use PatternState::*;
    let mut state = Start;
    for ch in input.chars() {
        state = match (state, ch) {
            (Start, 'a')     => InBs,
            (InBs, 'b')      => InBs,
            (InBs, 'c')      => End,
            (End,  _)        => Invalid,
            (_,    _)        => Invalid,
        };
        if state == Invalid {
            return false;
        }
    }
    state == End
}

Lvfalue

2 months ago

3.75ms

89.76kb

#[derive(PartialEq)]
pub enum State {
    Start,
    A,
    B,
    Done,
    Invalid,
}
impl State {
    fn t(&mut self, c: char) -> Self {
        match (self, c) {
            (State::Start, 'a') => State::A,
            (State::A, 'b') => State::B,
            (State::A, 'c') => State::Done,
            (State::B, 'b') => State::B,
            (State::B, 'c') => State::Done,
            _ => State::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut start = State::Start;
    for char in input.chars() {
        start = start.t(char);
        if start == State::Invalid {
            return false;
        }
    }
    start == State::Done
}

TheJanzap

2 months ago

3.62ms

89.76kb

#[derive(PartialEq)]
enum States {
    Start,
    A,
    B,
    Done,
}
impl States {
    fn transition(&mut self, c: char) -> Option<&States> {
        *self = match (&*self, c) {
            (States::Start, 'a') => States::A,
            (States::A, 'b') => States::B,
            (States::A, 'c') => States::Done,
            (States::B, 'b') => States::B,
            (States::B, 'c') => States::Done,
            _ => return None
        };
        Some(&*self)
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state = States::Start;
    for char in input.chars() {
        if let None = state.transition(char) {
            return false;
        }
    }
    state == States::Done
}

TheJanzap

2 months ago

3.41ms

89.76kb

#[derive(PartialEq, Copy, Clone)]
enum States {
    Start,
    A,
    B,
    Done,
}
impl States {
    fn transition(&mut self, c: char) -> bool {
        *self = match (*self, c) {
            (States::Start, 'a') => States::A,
            (States::A, 'b') => States::B,
            (States::A, 'c') => States::Done,
            (States::B, 'b') => States::B,
            (States::B, 'c') => States::Done,
            _ => return false
        };
        true
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state = States::Start;
    for char in input.chars() {
        if !state.transition(char) {
            return false;
        }
    }
    state == States::Done
}

Miguel Ángel Allende

maallende

2 months ago

3.83ms

91.82kb

#[derive(Debug, PartialEq)]
pub enum State {
    Start,
    A,
    AB,
    Found    
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    println!("Input: {}", input);
    let mut state: State = State::Start;
    for ch in input.chars() {
        state = match (state, ch.to_lowercase().next().unwrap()) {
            (State::Start, 'a') => State::A,
            (State::A, 'b') => State::AB,
            (State::A, 'c') => State::Found,            
            (State::AB, 'b') => State::AB,
            (State::AB, 'c') => State::Found,
            (_, _) => State::Start,                        
        };
        /*if state == State::Found {
            break;
        };*/
    };
    println!("Final state: {:?}", state);
    state == State::Found && input.len() > 0
}

Manuel Manjarres R.

manuelmj

2 months ago

3.61ms

90.64kb


#[derive(PartialEq)]
enum State{
    Start,
    GotA,
    GotB,
    Match, 
    Fail    
}
#[derive(PartialEq)]
struct PatternMacher{
    current_state : State, 
    pattern: String
}
impl PatternMacher { 
    fn new(pattern: &str) -> Self{
        PatternMacher{
            current_state : State::Start, 
            pattern : pattern.to_string()
        }
    }
    fn transition(&mut self, caracter: char) -> bool {
        self.current_state = match (&self.current_state, caracter){
            (State::Start, 'a') => State::GotA,
            (State::GotA,'b') | (State::GotB, 'b') => State::GotB,
            (State::GotB,'c') | (State::GotA, 'c') => State::Match,
            (_,_) => State::Fail,
        };
        
        self.current_state == State::Match
    }
    fn get_pattern(&mut self) -> bool {
        let pattern: String = self.pattern.drain(..).collect();
    
        let last_pos = pattern.chars().count().saturating_sub(1);
        let mut matched = false;
        
        for (i, c) in pattern.chars().enumerate() {
            if self.transition(c.to_ascii_lowercase()) && i == last_pos {
                matched = true;
            }
        }
        matched
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut  patter_machine: PatternMacher = PatternMacher::new(&input); 
    let result = patter_machine.get_pattern();
    result 
}

Arpan Shingala

arpan-vs

2 months ago

3.33ms

89.76kb

use std::cmp::PartialEq;
#[derive(Debug, PartialEq)]
enum State {
    Init,
    A,
    B,
    C
}
impl State {
    fn transitions(&self, c: char) -> Option<State> {
        match (self, c) {
            (Self::Init, 'a') => Some(Self::A),
            (Self::A, 'b') => Some(Self::B),
            (Self::B, 'b') => Some(Self::B),
            (Self::A, 'c') => Some(Self::C),
            (Self::B, 'c') => Some(Self::C),
            _ => None
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let final_state = input.chars().into_iter().fold(Some(State::Init),|accu, c|{
        if let Some(state) = accu {
            state.transitions(c)
        } else {
            return None;
        }
    });
    match final_state {
        Some(State::C) => true,
        _ => false,
    }
}

Algorab

2 months ago

3.38ms

89.76kb

use std::cmp::PartialEq;
#[derive(Debug, PartialEq)]
enum State {
    Init,
    A,
    B,
    C
}
impl State {
    fn transitions(&self, c: char) -> Option<State> {
        match (self, c) {
            (Self::Init, 'a') => Some(Self::A),
            (Self::A, 'b') => Some(Self::B),
            (Self::B, 'b') => Some(Self::B),
            (Self::A, 'c') => Some(Self::C),
            (Self::B, 'c') => Some(Self::C),
            _ => None
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let final_state = input.chars().into_iter().fold(Some(State::Init),|accu, c|{
        if let Some(state) = accu {
            state.transitions(c)
        } else {
            return None;
        }
    });
    match final_state {
        Some(State::C) => true,
        _ => false,
    }
}

GunGraveCpp

2 months ago

3.39ms

89.76kb

#[derive(Debug, PartialEq)]
enum State {
    Start,
    FindA,
    SkipB,
    FinalC,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for el in input.chars() {
        match (el, &state) {
            ('a', State::FindA | State::Start) => state = State::FindA,
            ('c', State::FindA | State::SkipB) => state = State::FinalC,
            ('b', State::FindA) => state = State::SkipB,
            ('b', State::SkipB) => {}
            (_, _) => state = State::Start,
        }
    }
    if state == State::FinalC {
        return true;
    } else {
        false
    }
}

GunGraveCpp

2 months ago

6.23ms

89.76kb

#[derive(Debug, PartialEq)]
enum State {
    Start,
    FindA,
    SkipB,
    FinalC,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for el in input.chars() {
        match (el, &state) {
            ('a', State::FindA | State::Start) => state = State::FindA,
            ('c', State::FindA | State::SkipB) => state = State::FinalC,
            ('b', State::FindA) => state = State::SkipB,
            ('b', State::SkipB) => {}
            (_, _) => state = State::Start,
        }
    }
    if state == State::FinalC {
        return true;
    } else {
        false
    }
}

manu3618

3 months ago

3.27ms

92.26kb

#[derive(PartialEq, Eq)]
enum State {
    O,
    A,
    B, 
    C,
}
impl State {
    pub fn change(&self, i: char) -> Option<Self> {
        match (self, i) {
            (Self::O, 'a') => Some(Self::A),
            (Self::A, 'b') => Some(Self::B),
            (Self::B, 'b') => Some(Self::B),
            (Self::A, 'c') => Some(Self::C),
            (Self::B, 'c') => Some(Self::C),
            _ => None 
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    dbg!(&input);
    let mut state = State::O;
    for c in input.chars() {
        let pouet = state.change(c); 
        if pouet.is_none(){
            return false
        } else {
            state = pouet.unwrap()
        }
    }
    state == State::C
}

Christophe Pronier

chrpron

3 months ago

3.28ms

91.52kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let chain = input.chars().collect::<Vec<char>>();
    if input.len() > 0 {
    if chain[0] == 'a' && chain[chain.len()-1] == 'c'  {
        if chain.len() > 2 {
            for i in 1..chain.len()-1 {
                if chain[i] != 'b' {
                    return false
                }
            }
        }
        return true
    }
    }
    false
}

almanaxxx

3 months ago

4.71ms

89.76kb

enum States{
    START,
    A,
    AB,
    MATCH,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = States::START;
    for ch in input.chars() {
        state = match state {
            States::START =>
                match ch {
                    'a' => States::A,
                    _ => return false
                },
            States::A =>
                match ch {
                    'b' => States::AB,
                    'c' => States::MATCH,
                    _ => return false
                },
            States::AB =>
                match ch {
                    'c' => States::MATCH,
                    'b' => States::AB,
                    _ => return false
                },
            States::MATCH => return false
        };
    }
    match state { States::MATCH => true, _ => false }
}

Wouter

WouterMartens

3 months ago

3.71ms

89.76kb

enum State {
    Start,
    A,
    B,
    C,
    Invalid,
}
impl State {
    fn transition(self, byte: &u8) -> Self {
        match (byte, self) {
            (b, State::Start) if *b == b'a' => State::A,
            (b, State::A | State::B) if *b == b'b' => State::B,
            (b, State::A | State::B) if *b == b'c' => State::C,
            _ => State::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    if input.is_empty() {
        return false;
    }
    let final_state = input
        .as_bytes()
        .iter()
        .fold(State::Start, State::transition);
        
    matches!(final_state, State::C)
}

whhc

3 months ago

4.09ms

89.76kb

#[derive(PartialEq)]
pub enum State {
    Init,
    A,
    B,
    C,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Init;
    for c in input.chars() {
        state = match (c, state) {
            ('a', State::Init) => State::A,
            ('b', State::A | State::B) => State::B,
            ('c', State::A | State::B) => State::C,
            _ => return false,
        }
    }
    state == State::C
}

David Manca

medzernik

3 months ago

3.26ms

91.67kb

#[derive(PartialEq)]
enum State {
    A,
    B,
    C
}
pub fn recognize_pattern(input: &str) -> bool {
    println!("pattern: {}", input);
    let mut state = None;
    for c in input.chars() {
        state = match state {
            None => match c {
                'a' => Some(State::A),
                _ => return false
            },
            Some(State::A) => match c {
                'b' => Some(State::B),
                'c' => Some(State::C),
                _ => return false
            },
            Some(State::B) => match c {
                'b' => Some(State::B),
                'c' => Some(State::C),
                _ => return false,
            }
            Some(State::C) => return false,
        };
    }
    if state == Some(State::C) {
        return true;
    }
    false
}

Baron Curtin

baroncurtin2

3 months ago

3.20ms

89.76kb

#[derive(Debug, Clone, PartialEq)]
pub enum State {
    Start,
    SeenA,
    SeenB,
    Accept,
    Reject,
}
pub fn recognize_pattern(input: &str) -> bool {
    if input.is_empty() {
        return false;
    }
    let mut state = State::Start;
    for ch in input.chars() {
        state = match (state, ch) {
            (State::Start, 'a') => State::SeenA,
            (State::Start, _) => State::Reject,
            
            (State::SeenA, 'b') => State::SeenB,
            (State::SeenA, 'c') => State::Accept,
            (State::SeenA, _) => State::Reject,
            (State::SeenB, 'b') => State::SeenB,
            (State::SeenB, 'c') => State::Accept,
            (State::SeenB, _) => State::Reject,
            (State::Accept, _) => State::Reject,
            (State::Reject, _) => State::Reject,
        };
        // early termination optimization
        if state == State::Reject {
            return false;
        }
    }   
    state == State::Accept
}

Evrins Hu

evrins

3 months ago

3.43ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    #[derive(PartialEq)]
    enum State {
        Init,
        A,
        B,
        C,
    }
    let mut state = State::Init;
    for ch in input.chars() {
        state = match (ch, state) {
            ('a', State::Init) => State::A,
            ('b', State::A | State::B) => State::B,
            ('c', State::A | State::B) => State::C,
            _ => return false,
        }
    }
    state == State::C
}

Alexander Y

unixander

3 months ago

3.24ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    #[derive(PartialEq)]
    enum State {
        Init,
        A,
        B,
        C,
    }
    let mut state = State::Init;
    for ch in input.chars() {
        state = match (ch, state) {
            ('a', State::Init) => State::A,
            ('b', State::A | State::B) => State::B,
            ('c', State::A | State::B) => State::C,
            _ => return false,
        }
    }
    state == State::C
}

johndoe30bc

4 months ago

3.47ms

89.76kb

#[derive(PartialEq)]
enum State {
    Initial,
    A,
    B,
    C,
}
pub fn recognize_pattern(input: &str) -> bool {
    use State::*;
    let mut state = Initial;
    for c in input.chars() {
        state = match (c, state) {
            ('a', Initial) => A,
            ('b', A | B) => B,
            ('c', A | B) => C,
            _ => return false,
        }
    }
    state == State::C
}

xxxxsk

4 months ago

4.45ms

91.52kb

fn main() {
    for i in 8..1 {
        println!("{}", i);
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let chars_vec = input.chars().collect::<Vec<char>>();
    if chars_vec.len() < 2 {
        return false;
    }
    
    chars_vec.iter().enumerate().find(|&(index, &c)| {
        if c == 'a' {
            let mut cur = index + 1;
            // 允许零个或多个 b
            while cur < chars_vec.len() && chars_vec[cur] == 'b' {
                cur += 1;
            }
            // 必须到达 c 且是最后一个字符
            cur < chars_vec.len() && chars_vec[cur] == 'c' && cur == chars_vec.len() - 1
        } else {
            false
        }
    }).is_some()
}

xxxxsk

4 months ago

3.23ms

91.52kb

fn main() {
    for i in 8..1 {
        println!("{}", i);
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let chars_vec = input.chars().collect::<Vec<char>>();
    if chars_vec.len() < 2 {
        return false;
    }
    
    chars_vec.iter().enumerate().find(|&(index, &c)| {
        if c == 'a' {
            let mut cur = index + 1;
            // 允许零个或多个 b
            while cur < chars_vec.len() && chars_vec[cur] == 'b' {
                cur += 1;
            }
            // 必须到达 c 且是最后一个字符
            cur < chars_vec.len() && chars_vec[cur] == 'c' && cur == chars_vec.len() - 1
        } else {
            false
        }
    }).is_some()
}

Evgenii Grigorenko

grevgeny

4 months ago

4.17ms

89.76kb

#[derive(Debug, PartialEq)]
enum State {
    Start,
    A,
    B,
    C,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for ch in input.chars() {
        state = match (state, ch) {
            (State::Start, 'a') => State::A,
            (State::A, 'b') | (State::B, 'b') => State::B,
            (State::A, 'c') | (State::B, 'c') => State::C,
            _ => return false
        }
    }
    state == State::C
}

brucecox01

4 months ago

3.35ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    #[derive(PartialEq)]
    enum FSAStates {
        NeedA,
        OptionalBorC,
        NeedEOS,
    }
    let mut state = FSAStates::NeedA;
    for ch in input.chars() {
        match state {
            FSAStates::NeedA => {
                if ch != 'a' { return false; }
                state = FSAStates::OptionalBorC; 
            },
            FSAStates::OptionalBorC => {
                if ch == 'c' { state = FSAStates::NeedEOS }
                else if ch != 'b' { return false; }
            },
            FSAStates::NeedEOS => { return false; },
        }
    }
    state == FSAStates::NeedEOS
}

Elliott Draper

ejdraper

4 months ago

3.33ms

91.67kb

#[derive(PartialEq)]
enum State {
    A,
    B,
    C
}
pub fn recognize_pattern(input: &str) -> bool {
    println!("pattern: {}", input);
    let mut state = None;
    for c in input.chars() {
        state = match state {
            None => match c {
                'a' => Some(State::A),
                _ => return false
            },
            Some(State::A) => match c {
                'b' => Some(State::B),
                'c' => Some(State::C),
                _ => return false
            },
            Some(State::B) => match c {
                'b' => Some(State::B),
                'c' => Some(State::C),
                _ => return false,
            }
            Some(State::C) => return false,
        };
    }
    if state == Some(State::C) {
        return true;
    }
    false
}

Krzysztof Atłasik

katlasik

4 months ago

3.19ms

91.55kb

#[derive(PartialEq)]
enum State {
  A,B,C
}
pub fn recognize_pattern(input: &str) -> bool {
  let mut state = None;
  println!("{}", input);
  for c in input.chars() {
    state = match state {
      None => match c {
        'a' => Some(State::A),
        'b' => return false,
        'c' => return false,
        _ => return false,
      },
      Some(State::A) => match c {
        'c' => Some(State::C),
        'b' => Some(State::B),
        _ => return false,
      },
      Some(State::B) => match c {
        'b' => Some(State::B),
        'c' => Some(State::C),
        _ => return false,
      },
      Some(State::C) => return false
    };
  }
  if state == Some(State::C) {
    return true;
  }
  false
}

Philippe Massicotte

PMassicotte

4 months ago

3.62ms

89.76kb

#[derive(PartialEq)]
pub enum State {
    Init,
    A,
    B,
    C,
    Invalid,
}
impl State {
    pub fn transition(&self, c: char) -> Self {
        match (self, c) {
            (State::Init, 'a') => State::A,
            (State::A, 'b') | (State::B, 'b') => State::B,
            (State::A, 'c') | (State::B, 'c') => State::C,
            _ => State::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Init;
    let chars = input.chars();
    for c in chars {
        state = state.transition(c);
        if state == State::Invalid {
            return false;
        }
    }
    // Should ends in this state
    state == State::C
}

ggnne

4 months ago

3.31ms

89.76kb

#[derive(Debug, PartialEq)]
pub enum States {
    Empty,
    A,
    B,
    Matched,
    Invalid
}
impl States {
    pub fn transition(self, c: char) -> Self {
        match (self, c) {
            (States::Empty, 'a') => States::A,
            (States::A, 'b') | (States::B, 'b') => States::B,
            (States::A, 'c') | (States::B, 'c') => States::Matched,
            _ => States::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = States::Empty;
    for c in input.chars() {
        state = state.transition(c);
        if state == States::Invalid {
            break
        }
    }
    state == States::Matched
}

ggnne

4 months ago

3.15ms

89.76kb

#[derive(Debug)]
pub enum States {
    Empty,
    A,
    B,
    Matched,
    Invalid
}
impl States {
    pub fn transition(self, c: char) -> Self {
        match (self, c) {
            (States::Empty, 'a') => States::A,
            (States::A, 'b') | (States::B, 'b') => States::B,
            (States::A, 'c') | (States::B, 'c') => States::Matched,
            _ => States::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = States::Empty;
    let mut out = false;
    for c in input.chars() {
        state = state.transition(c);
        match state {
            States::Matched => { out = true }
            States::Invalid => { out = false; break },
            _ => ()
        }
    }
    out
}

Luigi Terrone

LuigiTer

4 months ago

4.11ms

89.76kb

#[derive(PartialEq)]
pub enum FSM {
    Init,
    A, 
    B, 
    C,
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state : FSM = FSM::Init;
    for c in input.chars() {
        match (state, c) {
            (FSM::Init, 'a') => state = FSM::A,
            (FSM::A | FSM::B, 'b') => state = FSM::B,
            (FSM::A | FSM::B, 'c') => state = FSM::C,
            _ => return false,
        }
    }
    
    state == FSM::C
}

Enes

enesscevik

4 months ago

3.08ms

89.76kb

#[derive(PartialEq)]
enum State {
    Init, 
    Start, 
    Mid,
    End
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut s = State::Init;
    for c in input.chars() {
        s = match (s, c) {
            (State::Init, 'a') => State::Start,
            (State::Start | State::Mid, 'b') => State::Mid, 
            (State::Start | State::Mid, 'c') => State::End,
            _ => return false,
        };
    }  
    s == State::End
}

ikatlinsky

4 months ago

4.04ms

89.76kb

#[derive(PartialEq)]
enum State {
    INITIAL, 
    START, 
    MID,
    END
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut s = State::INITIAL;
    for c in input.chars() {
        s = match (s, c) {
            (State::INITIAL, 'a') => State::START,
            (State::START | State::MID, 'b') => State::MID, 
            (State::START | State::MID, 'c') => State::END,
            _ => return false,
        };
    }
    
    s == State::END
}

LeonardoPinheiro23

5 months ago

3.57ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // finite state automaton of "ab*c"
    let mut input = input.chars();
    match input.next() {
        Some('a') => {},
        _ => return false,
    };
    match input.next_back() {
        Some('c') => {},
        _ => return false,
    };
    input.all(|c| c == 'b')
}

annececiledunand

5 months ago

3.71ms

89.76kb

#[derive(PartialEq)]
enum State {
    Start,
    A,
    B,
    C,
    Invalid,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for current_char in input.chars() {
        // new state is determined by current char iteration and previous state. 
        // Only if the previous state is allowing transition to the new char/state do we iterate.
        // Stop when incoherence with transitions 
        state = match (current_char, state) {
            ('a', State::Start) => State::A,
            ('b', State::A | State::B)  => State::B,
            ('c', State::B | State::A) => State::C,
            _ => State::Invalid,
        };
        if state == State::Invalid {
            return false;
        }
    }
    return state == State::C;
}

annececiledunand

5 months ago

3.38ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    if !input.starts_with('a') {
        return false;
    }
    if !input.ends_with('c') {
        return false;
    }
    let length = input.len(); 
    if length > 2 {
        for c in input.get(1..length-1).expect("Error with leght detection").chars() {
            if c != 'b' { return false; }
        }
    }
    return true;
}

michdorf

5 months ago

3.58ms

89.76kb

#[derive(PartialEq)]
enum State {
    INITIAL, 
    A, 
    B,
    C,
    FAILED
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut s = State::INITIAL;
    for c in input.chars() {
        s = match (s, c) {
            (State::INITIAL, 'a') => State::A,
            (State::A | State::B, 'b') => State::B, 
            (State::A | State::B, 'c') => State::C,
            _ => State::FAILED
        };
        if s == State::FAILED {
            return false; 
        }
    }
    
    s == State::C
}

Tommytto

5 months ago

3.64ms

91.52kb

#[derive(PartialEq)]
pub enum SearchState {
    Start,
    A,
    B,
    C,
    Fail,
}
impl SearchState {
    pub fn get_next(state: SearchState, val: char) -> SearchState {
        match (state, val) {
            (SearchState::Start, 'a') => SearchState::A,
            (SearchState::A | SearchState::B, 'b') => SearchState::B,
            (SearchState::A | SearchState::B, 'c') => SearchState::C,
            _ => SearchState::Fail,                     
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state = SearchState::Start;
    let chars: Vec<char> = input.chars().collect();
    for ch in chars {
        state = SearchState::get_next(state, ch);
        if state == SearchState::Fail {
            return false;
        }
    }
    if state == SearchState::C {
        true
    } else {
        false
    }
}