fn main() {
    use std::collections::HashSet;
    use Number::*;
    use Tile::*;
 
    let mut hand = vec![
        Dots(One),
        Dots(One),
        Dots(One),
        Dots(Two),
        Dots(Three),
        Dots(Four),
        Dots(Five),
        Dots(Six),
        Dots(Seven),
        Dots(Eight),
        Dots(Nine),
        Dots(Nine),
        Dots(Nine),
        East,
    ];
 
    hand.sort();
 
    let mut current: HashSet<Vec<Vec<Tile>>> = HashSet::new();
    current.insert(vec![]);
 
    for tile in hand.iter() {
        let mut temp = HashSet::new();
        for parts in current.iter() {
            for (i, part) in parts.iter().enumerate().filter(|(_, part)| part.len() < 3) {
                if let Some(new_part) = append(part, *tile) {
                    let mut new_parts: Vec<_> = parts.to_owned();
                    new_parts[i] = new_part;
                    new_parts.sort();
                    temp.insert(new_parts);
                }
            }
            let mut new_parts: Vec<_> = parts.to_owned();
            new_parts.push(vec![*tile]);
            new_parts.sort();
            temp.insert(new_parts);
        }
        current = temp;
    }
 
    let min_len: usize = current.iter().map(Vec::len).min().unwrap();
 
    current = current
        .into_iter()
        .filter(|parts| parts.len() == min_len)
        .collect();
 
    println!("{}", current.len());
    for parts in current.iter() {
        println!("{:?}", parts);
    }
}
 
fn append(part: &[Tile], tile: Tile) -> Option<Vec<Tile>> {
    use Tile::*;
    let mut part: Vec<_> = part.to_owned();
    part.push(tile);
    part.sort();
    if part.windows(2).all(|w| w[0] == w[1])
        || part.windows(2).all(|w| match w {
            [Dots(n1), Dots(n2)] if n1.diff(*n2) == 1 => true,
            [Bamboo(n1), Bamboo(n2)] if n1.diff(*n2) == 1 => true,
            [Characters(n1), Characters(n2)] if n1.diff(*n2) == 1 => true,
            _ => false,
        })
        || (match &part[..] {
            [Dots(n1), Dots(n2)] if n1.diff(*n2) == 2 => true,
            [Bamboo(n1), Bamboo(n2)] if n1.diff(*n2) == 2 => true,
            [Characters(n1), Characters(n2)] if n1.diff(*n2) == 2 => true,
            _ => false,
        })
    {
        Some(part)
    } else {
        None
    }
}
 
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Number {
    One = 1,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
}
 
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Tile {
    Dots(Number),
    Bamboo(Number),
    Characters(Number),
    East,
    South,
    West,
    North,
    Red,
    Green,
    White,
}
 
impl Number {
    fn diff(self, other: Self) -> i32 {
        (self as i32 - other as i32).abs()
    }
}
 

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