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

Algorab

8 hours 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

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

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

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

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

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

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

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

medzernik

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

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

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

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

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

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

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

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

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

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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

3 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
    }
}

Viktor Merkurev

fennr

3 months 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

3 months 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

4 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

4 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

4 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

4 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

4 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

4 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

4 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

5 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

5 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

5 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

5 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

5 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

5 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

5 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

5 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

5 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

5 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

6 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
}