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

Philippe Massicotte

PMassicotte

4 days 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

10 days 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

10 days 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

10 days 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

12 days 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

14 days 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

22 days 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

23 days 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

23 days 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

25 days 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

a month 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
    }
}

Viktor Merkurev

fennr

a month ago

3.02ms

89.76kb

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

Viktor Merkurev

fennr

a month ago

3.33ms

89.76kb

use std::collections::HashSet;
use std::cmp::Ordering;
#[derive(PartialEq)]
enum State {
    A,
    B,
    C
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state: State = State::A;
    for x in input.chars() {
        if x == 'a' {
            if state == State::A {
                state = State::B;
            } else {
                return false;
            }
        } else if x == 'b' {
            if state != State::B {
                return false;
            }
        } else if x == 'c' {
            if state == State::B || state == State::A {
                state = State::C;
            } else {
                return false;
            }
        } else{
            return false;
        }
    }
    return state == State::C;
}

wertion555

2 months ago

4.03ms

91.52kb

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

Hung Dinh

nhdinh

2 months ago

5.07ms

89.76kb

use std::collections::HashSet;
use std::cmp::Ordering;
#[derive(PartialEq)]
enum State {
    A,
    B,
    C
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state: State = State::A;
    for x in input.chars() {
        if x == 'a' {
            if state == State::A {
                state = State::B;
            } else {
                return false;
            }
        } else if x == 'b' {
            if state != State::B {
                return false;
            }
        } else if x == 'c' {
            if state == State::B || state == State::A {
                state = State::C;
            } else {
                return false;
            }
        } else{
            return false;
        }
    }
    return state == State::C;
}

Hung Dinh

nhdinh

2 months ago

4.32ms

91.56kb

use std::collections::HashSet;
use std::cmp::Ordering;
pub fn recognize_pattern(input: &str) -> bool {
    let chars = input.chars().collect::<Vec<_>>();
    return match chars.len().cmp(&2) {
        Ordering::Equal => chars[0] == 'a' && chars[1] == 'c',
        Ordering::Less => false,
        Ordering::Greater => if chars[0] != 'a' || chars[chars.len() - 1] != 'c' {
                false
            } else if chars[1] != 'b' || chars.iter().enumerate().filter(|(k,_)| *k != 0 && *k != chars.len() - 1).map(|(_,x)| *x).collect::<HashSet<_>>().len() != 1 {
                false
            } else {
                true
            },
    };
}

Jakub Wiśniewski

wisniewskij

2 months ago

5.38ms

89.76kb

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

Jason

Jason-fy-wang

2 months ago

4.67ms

89.76kb

enum  STATE {
    START,
    A,
    B,
    C,
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    if !input.starts_with("a") || !input.ends_with("c") {
        return false;
    }
    let count = input.chars().count();
    let mut state = STATE::START;
    for (idx, c) in input.chars().enumerate(){
        match (state, idx==count-1, c) {
            (STATE::START,false, 'a') => {
                state = STATE::A;
            },
            (STATE::A|STATE::B, false, 'b') => {
                state = STATE::B;
            },
            (STATE::A|STATE::B,true, 'c') => {
                state = STATE::C;
            },
            _ => {
                return false;
            }
        }
    }
    true
}

Jason

Jason-fy-wang

2 months ago

17.51ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    if !input.starts_with("a") || !input.ends_with("c") {
        return false;
    }
    let count = input.chars().count();
    
    for i in 1..count - 1 {
        if input.chars().nth(i) != Some('b') {
            return false;
        }
    }
    true
}

syberianbull

3 months ago

3.23ms

89.76kb

enum State {
    Start,
    A,
    B,
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state: State = State::Start;
    let length: usize = input.len();
    for (i, letter) in input.chars().enumerate() {
        match (state, letter, length - 1 == i) {
            (State::Start, 'a', false) => state = State::A,
            (State::A | State::B, 'b', false) => state = State::B,
            (State::A | State::B, 'c', true) => return true,
            _ => return false,
        }
    }
    false
}

Aurimas Kuniutis

auriku

3 months ago

4.38ms

89.76kb

    pub fn recognize_pattern(input: &str) -> bool {
        if input.len() == 2 && input == "ac"{
            return true;
        } else {
            for (i,char) in input.chars().enumerate() {
                if i == 0 && char == 'a' {
                    continue;
                } else if i == 0 && char != 'a' {
                    break;
                } else if i != input.len() - 1 && char != 'b' {
                    break;
                } else if i == input.len() - 1 && char == 'c' {
                    return true;
                }
    
            }
        }
        false
    }

Robbie K

va1ha11a

3 months ago

4.13ms

89.76kb

#[derive(PartialEq)]
enum PatternState {
    Start,
    FoundA,
    Completed,
    Invalid,
}
impl PatternState {
    fn next(&self, c: char) -> PatternState {
        match self {
            PatternState::Start => {
                if c == 'a' {
                    PatternState::FoundA
                } else {
                    PatternState::Invalid
                }
            }
            PatternState::FoundA => {
                if c == 'b' {
                    PatternState::FoundA
                } else if c == 'c' {
                    PatternState::Completed
                } else {
                    PatternState::Invalid
                }
            }
            PatternState::Completed => PatternState::Invalid,
            PatternState::Invalid => PatternState::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    if input.is_empty() {
        return false;
    }
    let mut pattern_state: PatternState = PatternState::Start;
    for c in input.chars() {
        pattern_state = pattern_state.next(c);
        if pattern_state == PatternState::Invalid {
            return false;
        }
    }
    pattern_state == PatternState::Completed
}

VerweyFr

3 months ago

3.87ms

89.76kb

#[derive(Clone, PartialEq)]
enum State {
    NeedOneA,
    NeedBorC,
    NeedNothing
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state: State = State::NeedOneA;
    for c in input.chars() {
        match (state.clone(), c) {
            (State::NeedOneA, 'a') => state = State::NeedBorC,          
            (State::NeedBorC, f) if f == 'b' || f == 'c' => {
                if c =='c' {
                    state = State::NeedNothing
                }
            },
            _ => return false
        }
    }
    if state == State::NeedNothing {
       true
    }
    else {
       false
    }
}

Yixian Du

duyixian1234

3 months ago

4.54ms

89.76kb

#[derive(PartialEq)]
pub enum StateMachine {
    Initial,
    Final,
    Intermediate,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = StateMachine::Initial;
    for c in input.chars() {
        match state {
            StateMachine::Initial => match c {
                'a' => state = StateMachine::Intermediate,
                _ => return false,
            },
            StateMachine::Intermediate => match c {
                'b' => state = StateMachine::Intermediate,
                'c' => state = StateMachine::Final,
                _ => return false,
            },
            StateMachine::Final => match c {
                _ => return false,
            },
        }
    }
    state == StateMachine::Final
}

gsspdev

3 months ago

4.40ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut current_state = State::Other;
    for c in input.chars() {
        current_state = match c {
            'a' => State::A,
            'b' => match current_state {
                State::A | State::B => State::B,
                _ => State::Other,
            }
            'c' => match current_state {
                State::A | State::B => State::C,
                _ => State::Other,
            }
            _ => State::Other,
        }
    };
    match current_state {
        State::C => true,
        _ => false,
    }
}
enum State {
        A,
        B,
        C,
        Other,
}

lugtester

3 months ago

3.92ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut current_state = State::Other;
    for i in input.chars() {
        current_state = match i {
            'a' => State::A,
            'b' => match current_state {
                State::A | State::B => State::B,
                _ => State::Other
            },
            'c' => match current_state {
                State::A | State::B => State::C,
                _ => State::Other
            } 
            x => State::Other
        };
    }
    match current_state {
        State::C => true,
        _ => false
    }
}
enum State {
    Other,
    A,
    B,
    C
}

Anna Komarova

Vlasanya

3 months ago

3.94ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    enum State {
        Start,
        GotA,
        GotB,
        GotC,
    }
    use State::*;
    let mut state = Start;
    for ch in input.chars() {
        state = match state {
            Start => {
                if ch == 'a' {
                    GotA
                } else {
                    return false;
                }
            }
            GotA => {
                if ch == 'b' {
                    GotB
                } else if ch == 'c' {
                    GotC
                } else {
                    return false;
                }
            }
            GotB => {
                if ch == 'b' {
                    GotB
                } else if ch == 'c' {
                    GotC
                } else {
                    return false;
                }
            }
            GotC => {
                return false;
            }
        };
    }
    
    matches!(state, GotC)
}

Anna Komarova

Vlasanya

4 months ago

3.61ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    enum State {
        Start,
        GotA,
        GotB,
        GotC,
    }
    use State::*;
    let mut state = Start;
    for ch in input.chars() {
        state = match state {
            Start => {
                if ch == 'a' {
                    GotA
                } else {
                    return false;
                }
            }
            GotA => {
                if ch == 'b' {
                    GotB
                } else if ch == 'c' {
                    GotC
                } else {
                    return false;
                }
            }
            GotB => {
                if ch == 'b' {
                    GotB
                } else if ch == 'c' {
                    GotC
                } else {
                    return false;
                }
            }
            GotC => {
                return false;
            }
        };
    }
    
    matches!(state, GotC)
}

Icarus

IcarusxB

4 months ago

4.24ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    enum State {
        Start,   
        Middle,  
        End,
    }
    let mut state = State::Start;
    for ch in input.chars() {
        state = match state {
            State::Start => {
                if ch == 'a' {
                    State::Middle
                } else {
                    return false
                }
            }
            State::Middle => {
                if ch == 'b' {
                    State::Middle  
                } else if ch == 'c' {
                    State::End  
                } else {
                    return false  
                }
            }
            State::End => {
                return false 
            }
        };
    }
    if let State::End = state {
        true
    } else {
        false
    }
}

AnKarl

Zythophilus

4 months ago

4.39ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    if input.is_empty() {
        return false
    } else {
        let mut state = States::First;
        for c in input.chars() {
            match state {
                States::First => match c {
                    'a' => state = States::Second,
                    _ => return false,
                }
                States::Second => match c {
                    'b' => (),
                    'c' => state = States::Third,
                    _ => return false,
                }
                States::Third => match c {
                    _ => return false,
                }
            }
        }
        state == States::Third
    }
}
#[derive(PartialEq)]
pub enum States {
    First,
    Second,
    Third,
}

Ayushman Rathore

Spartan09

4 months ago

4.58ms

89.76kb

#[derive(PartialEq)]
pub enum StateMachine {
    Initial,
    Final,
    Intermediate,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = StateMachine::Initial;
    for c in input.chars() {
        match state {
            StateMachine::Initial => match c {
                'a' => state = StateMachine::Intermediate,
                _ => return false,
            },
            StateMachine::Intermediate => match c {
                'b' => state = StateMachine::Intermediate,
                'c' => state = StateMachine::Final,
                _ => return false,
            },
            StateMachine::Final => match c {
                _ => return false,
            },
        }
    }
    state == StateMachine::Final
}

Ayushman Rathore

Spartan09

4 months ago

3.44ms

89.76kb

#[derive(PartialEq)]
pub enum StateMachine {
    Initial,
    Final,
    Intermediate,
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = StateMachine::Initial;
    for c in input.chars() {
        match state {
            StateMachine::Initial => match c {
                'a' => state = StateMachine::Intermediate,
                _ => return false,
            },
            StateMachine::Intermediate => match c {
                'b' => state = StateMachine::Intermediate,
                'c' => state = StateMachine::Final,
                _ => return false,
            },
            StateMachine::Final => match c {
                _ => return false,
            },
        }
    }
    state == StateMachine::Final
}

rawar089

5 months ago

4.22ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    let mut current_state = FSA::STATEA;
    for c in input.chars() {
        current_state = current_state.transition(c);
    }
    current_state.is_end_state()
}
pub enum FSA {
    STATEA,
    STATEBs,
    STATEC,
    ERROR,
}
impl FSA {
    pub fn transition(&self, symbol: char) -> FSA {
        match (&self, symbol) {
            (FSA::STATEA, 'a') => FSA::STATEBs,
            (FSA::STATEBs, 'b') => FSA::STATEBs,
            (FSA::STATEBs, 'c') => FSA::STATEC,
            _ => FSA::ERROR,
        }
    }
    pub fn is_end_state(&self) -> bool {
        match  self{
            FSA::STATEC => return true,
            _ => return false,
        }
    }
}

Nikita Smirnov

Nismirno

5 months ago

3.78ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut chars = input.chars();
    let mut current_state: State = match chars.next() {
        None => {
            return false;
        }
        Some(char) => State::from(char),
    };
    for char in chars {
        let next_state = State::from(char);
        if !current_state.available_states().contains(&next_state) {
            return false;
        }
        current_state = next_state;
    }
    match current_state {
        State::C => true,
        _ => false,
    }
}
#[derive(PartialEq, PartialOrd)]
enum State {
    A,
    B,
    C,
    Other,
}
impl From<char> for State {
    fn from(value: char) -> Self {
        match value {
            'a' => Self::A,
            'b' => Self::B,
            'c' => Self::C,
            _ => Self::Other,
        }
    }
}
impl State {
    pub fn available_states(&self) -> Vec<State> {
        match self {
            Self::A => vec![Self::B, Self::C],
            Self::B => vec![Self::B, Self::C],
            Self::C => vec![],
            Self::Other => vec![],
        }
    }
}

Christopher Nielson

c-nielson

5 months ago

3.11ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    if input.is_empty() { return false; }
    let mut chars = input.chars().into_iter();
    match chars.next() {
        Some('a') => (),
        _ => return false,
    }
    loop {
        match chars.next() {
            Some('b') => continue,
            Some('c') => break,
            _ => return false,
        }
    }
    if chars.next().is_none() { true } else { false }
}

vikingNR

5 months ago

3.41ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut iter = input.chars();
    match iter.next(){
        Some('a') => (),
        _ => return false
    }
    loop{
        match iter.next(){
            Some('b') => continue,
            Some('c') => break,
            _ => return false
        }
    }
    if iter.next() == None {
        return true
    }
    false
}

Sthitaprajna Sahu

sthitasahu

5 months ago

3.22ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
     if input.is_empty() {
        return false
    }
    let mut chars = input.chars();
    let mut current: State = chars.next().unwrap().into();
    for c in chars {
        let s: State = c.into();
        let possible = current.transition();
        if !possible.contains(&s) {
            return false
        } 
        current = s;
    }
    if current == State::C {
        true
    } else {
        false
    }
}
#[derive(PartialEq, Eq, Debug)]
enum State {
    A,
    B,
    C,
    Other
}
impl From<char> for State {
    fn from(value: char) -> Self {
        match value {
            'a' => State::A,
            'b' => State::B,
            'c' => State::C,
            _ => State::Other
        }
    }
}
impl State {
    fn transition(&self) -> Vec<State> {
        match self {
            State::A => vec![State::B, State::C],
            State::B => vec![State::B, State::C],
            State::C => vec![],
            State::Other => vec![State::A, State::Other],
        }
    }
}

Sthitaprajna Sahu

sthitasahu

5 months ago

4.40ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
     if input.is_empty() {
        return false
    }
    let mut chars = input.chars();
    let mut current: State = chars.next().unwrap().into();
    for c in chars {
        let s: State = c.into();
        let possible = current.transition();
        if !possible.contains(&s) {
            return false
        } 
        current = s;
    }
    if current == State::C {
        true
    } else {
        false
    }
}
#[derive(PartialEq, Eq, Debug)]
enum State {
    A,
    B,
    C,
    Other
}
impl From<char> for State {
    fn from(value: char) -> Self {
        match value {
            'a' => State::A,
            'b' => State::B,
            'c' => State::C,
            _ => State::Other
        }
    }
}
impl State {
    fn transition(&self) -> Vec<State> {
        match self {
            State::A => vec![State::B, State::C],
            State::B => vec![State::B, State::C],
            State::C => vec![],
            State::Other => vec![State::A, State::Other],
        }
    }
}

Florian Gaudin-Delrieu

FlorianGD

5 months ago

3.56ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    if input.is_empty() {
        return false
    }
    let mut chars = input.chars();
    let mut current: State = chars.next().unwrap().into();
    for c in chars {
        let s: State = c.into();
        let possible = current.transition();
        if !possible.contains(&s) {
            return false
        } 
        current = s;
    }
    if current == State::C {
        true
    } else {
        false
    }
}
#[derive(PartialEq, Eq, Debug)]
enum State {
    A,
    B,
    C,
    Other
}
impl From<char> for State {
    fn from(value: char) -> Self {
        match value {
            'a' => State::A,
            'b' => State::B,
            'c' => State::C,
            _ => State::Other
        }
    }
}
impl State {
    fn transition(&self) -> Vec<State> {
        match self {
            State::A => vec![State::B, State::C],
            State::B => vec![State::B, State::C],
            State::C => vec![],
            State::Other => vec![State::A, State::Other],
        }
    }
}

nedrw

5 months ago

5.52ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut s = input.chars();
    if input.len() < 2 { return false; }
    else {
        match s.next() {
            Some(c) => if c != 'a' { return false; },
            None => return false,
        };
        match s.last() {
            Some(c) => if c != 'c' { return false; },
            None => return false,
        }
        let chars = input.chars().skip(1);
        for (i, c) in chars.enumerate() {
            if i < input.len() - 2 && c != 'b' { return false; }
        }
    }
    true
}

dawwestk

5 months ago

4.04ms

89.76kb

pub enum LetterState {
    IsA,
    IsB,
    IsC,
    Invalid,
}
pub fn get_state(c: &char) -> LetterState {
    match c {
        'a' => LetterState::IsA,
        'b' => LetterState::IsB,
        'c' => LetterState::IsC,
        _ => LetterState::Invalid,
    }
}
pub struct Letter {
    pub value: LetterState
}
impl Letter {
    pub fn new(c: char) -> Self {
        Self { value: get_state(&c) }
    }
    pub fn transition(&mut self, next: &Letter) {
        match self.value {
            LetterState::IsA => {
                match next.value {
                    LetterState::IsA => self.value = LetterState::Invalid,
                    LetterState::IsB => self.value = LetterState::IsB,
                    LetterState::IsC => self.value = LetterState::IsC,
                    LetterState::Invalid => self.value = LetterState::Invalid,
                }
            },
            LetterState::IsB => {
                match next.value {
                    LetterState::IsA => self.value = LetterState::Invalid,
                    LetterState::IsB => (),
                    LetterState::IsC => self.value = LetterState::IsC,
                    LetterState::Invalid => self.value = LetterState::Invalid,
                }
            },
            LetterState::IsC => self.value = LetterState::Invalid,
            LetterState::Invalid => self.value = LetterState::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut chars = input.chars();
    if let Some(current_char) = chars.next() {
        let mut current = Letter::new(current_char);
        while let Some(c) = chars.next() {
            current.transition(&Letter::new(c));
            match current.value {
                LetterState::IsA | LetterState::IsB | LetterState::IsC => (),
                LetterState::Invalid => return false,
            }
        }
        match current.value {
            LetterState::IsA | LetterState::IsB | LetterState::Invalid => return false, 
            LetterState::IsC => return true,
        }
    } else {
        return false;
    }
}

PangoSea

kapaseker

5 months ago

4.25ms

89.76kb


#[derive(Debug)]
enum State {
    Start,
    SeenA,
    SeenB,
    SeenC,
    Invalid,
}
fn transition(state: State, input: char) -> State {
    match state {
        State::Start => match input {
            'a' => State::SeenA,
            _ => State::Invalid,
        },
        State::SeenA => match input {
            'b' => State::SeenB,
            'c' => State::SeenC,
            _ => State::Invalid,
        },
        State::SeenB => match input {
            'b' => State::SeenB,
            'c' => State::SeenC,
            _ => State::Invalid,
        },
        State::SeenC => State::Invalid,
        State::Invalid => State::Invalid,
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for c in input.chars() {
        state = transition(state, c);
        if let State::Invalid = state {
            return false;
        }
    }
    matches!(state, State::SeenC)
}

Marco-Normal

5 months ago

4.07ms

91.55kb

pub enum States {
    Start,
    SeenA,
    SeenB,
    SeenC,
}
pub struct Machine {
    state: States
}
impl Machine {
    pub fn new() -> Self {
        Self {
            state: States::Start
        }
    }
    pub fn start(&mut self) {
        self.state = States::Start
    }
    pub fn a(&mut self) {
        match self.state {
            _ => self.state = States::SeenA,
        }
    }
    pub fn b(&mut self) {
        match self.state {
            States::Start => (),
            States::SeenC => self.state = States::Start,
            _ => self.state = States::SeenB,
        }
    }
    pub fn c(&mut self) {
        match self.state {
            States::Start => (),
            States::SeenA => self.state = States::SeenC,
            States::SeenB => self.state = States::SeenC,
            _ => self.state = States::Start
        }
    }
    pub fn pattern(&self) -> bool {
        match self.state {
            States::SeenC => true,
            _ => false,
        }
    }
    pub fn find_pattern(&mut self, pat: &str) -> bool {
        for ch in pat.chars() {
            match ch {
                'a' => self.a(),
                'b' => self.b(),
                'c' => self.c(),
                _ => self.start(),
            } 
        }
        if self.pattern() {
            return true;
        }
        return false;
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut machine = Machine::new();
    println!("{input}");
    machine.find_pattern(input)
}

Mikhail Shutov

mshutov

5 months ago

3.24ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Initial;
    for ch in input.chars() {
        let next_state = accept(&state, ch);
        match next_state {
            State::Failed => { return false; }
            _ => {
                state = next_state;
            }
        }
    }
    match state {
        State::Found => {true},
        _ => {false}
    }
}
fn accept(state: &State, next_char: char) -> State {
    match state {
        State::Initial => {
            if next_char == 'a' {State::FoundA} else {State::Failed}
        }
        State::FoundA => {
            if next_char == 'b' {State::FoundB}
            else if next_char == 'c' {State::Found}
            else {State::Failed}
        }
        State::FoundB => {
            if next_char == 'b' {State::FoundB}
            else if next_char == 'c' {State::Found}
            else {State::Failed}
        }
        State::Found => State::Failed,
        State::Failed => State::Failed
    }
}
enum State {
    Initial,
    FoundA,
    FoundB,
    Found,
    Failed,
}

aey4

5 months ago

3.90ms

89.76kb

#[derive(PartialEq)]
enum State {
    Start,
    A,
    B,
    C
}                                                                                            
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 {
            State::Start => match ch {
                'a' => State::A,
                _ => return false,
            },
            State::A => match ch {
                'b' => State::B,
                'c' => State::C,
                _ => return false,
            },
            State::B => match ch {
                'b' => State::B,
                'c' => State::C,
                _ => return false,
            },
            State::C => match ch {
                _ => return false,
            },
        }
    }
    state == State::C
}

Joe Schneider

josschne

5 months ago

4.05ms

89.76kb

enum State {
    Start,
    FoundA,
    FoundB,
    FoundC,
    Rejected
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for c in input.chars() {
        state = match state {
            State::Start => {
                match c {
                    'a' => State::FoundA,
                    _ => State::Rejected
                }
            },
            State::FoundA => {
                match c {
                    'b' => State::FoundB,
                    'c' => State::FoundC,
                    _ => State::Rejected
                }
            },
            State::FoundB => {
                match c {
                    'b' => State::FoundB,
                    'c' => State::FoundC,
                    _ => State::Rejected
                }
            },
            State::FoundC => State::Rejected,
            State::Rejected => State::Rejected
        }
    }
    
    matches!(state, State::FoundC)
}

Benjamin Falk

lumio

5 months ago

3.80ms

89.76kb

#[derive(PartialEq)]
enum State {
    Start,
    OnA,
    OnB,
    Match,
    Invalid,
}
impl State {
    fn transition(&self, c: char) -> Self {
        match (self, c) {
            (State::Start, 'a') => State::OnA,
            (State::OnA, 'b') => State::OnB,
            (State::OnA, 'c') => State::Match,
            (State::OnB, 'b') => State::OnB,
            (State::OnB, 'c') => State::Match,
            (_, _) => State::Invalid,
        }
    }
}
pub fn recognize_pattern(input: &str) -> bool {
    let mut state = State::Start;
    for c in input.chars() {
        state = state.transition(c);
        if state == State::Invalid {
            break;
        }
    }
    state == State::Match
}

Ahmet Özcan

ahmetoozcan

5 months ago

3.16ms

89.76kb

#[derive(PartialEq)]
enum State {
    Start,
    OneA,
    ZeroOrMoreB,
    OneC,
    Finish,
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    if input.is_empty() {
        return false;
    }
    let mut state = State::Start;
    let mut chars = input.chars().peekable();
    while state != State::Finish {
        match state {
            State::Start => {
                if let Some(&ch) = chars.peek() {
                    if ch == 'a' {
                        chars.next();
                        state = State::OneA;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
            State::OneA | State::ZeroOrMoreB => {
                if let Some(&ch) = chars.peek() {
                    if ch == 'c' {
                        chars.next();
                        state = State::OneC;
                    } else if ch == 'b' {
                        chars.next();
                        state = State::ZeroOrMoreB;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
            State::OneC => {
                if let Some(&_ch) = chars.peek() {
                    return false;
                } else {
                    state = State::Finish;
                }
            }
            _ => {
                break;
            }
        }
    }
    true
}

Balint Toth

tbali0524

5 months ago

3.29ms

89.76kb

#[derive(PartialEq)]
enum State {
    Start,
    FoundA,
    FoundC,
    Invalid,
}
pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    let mut state = State::Start;
    for c in input.chars() {
        state = match state {
            State::Start => {
                match c {
                    'a' => State::FoundA,
                    _ => State::Invalid,
                }
            },
            State::FoundA => {
                match c {
                    'b' => State::FoundA,
                    'c' => State::FoundC,
                    _ => State::Invalid,
                }
            },
            State::FoundC => State::Invalid,
            State::Invalid => State::Invalid,
        };
    }
    state == State::FoundC
}

zahrajavar

5 months ago

3.22ms

89.76kb

pub fn recognize_pattern(input: &str) -> bool {
    // Implement your finite state automaton here
    enum State{
        Start,
        StateA,
        StateB,
        Reject,
        Accept,
    }
    impl State{
        fn transition(&self, c:char) -> State{
            match (self,c){
                (Self::Start, 'a') => Self::StateA,
                (Self::StateA, 'b') => Self::StateB,
                (Self::StateA, 'c') => Self::Accept,
                (Self::StateB, 'b') => Self::StateB,
                (Self::StateB, 'c') => Self::Accept,
                (_,_) => State::Reject,
            }
        }
    }
    let mut state = State::Start;
    for character in input.chars(){
        state = State::transition(&state,character);
        if let State::Reject = state{
            return false;
        }
    }
    if let State::Accept =state{
        return true;
    }
    false
}