create_strings.rs

use std::fmt::Debug;
use std::io::*;

fn reader() -> WordReader {
    WordReader::new()
}

fn writer() -> BufWriter<Stdout> {
    BufWriter::new(stdout())
}
struct WordReader {
    buf: Vec<u8>,
    pos: usize,
    lock: std::io::StdinLock<'static>,
}

impl WordReader {
    fn new() -> Self {
        let r = unsafe { &*Box::into_raw(Box::new(stdin())) };
        Self {
            lock: r.lock(),
            buf: Vec::new(),
            pos: 0,
        }
    }
    fn next_line(&mut self) -> bool {
        self.buf.clear();
        self.pos = 0;
        self.lock.read_until(b'\n', &mut self.buf).unwrap_or(0) > 0
    }
    fn is_whitespace(c: u8) -> bool {
        c == b' ' || c == b'\r' || c == b'\n' || c == b'\t'
    }
    fn byte(&mut self) -> Option<u8> {
        if self.pos == self.buf.len() && !self.next_line() {
            return None;
        }
        self.pos += 1;
        Some(self.buf[self.pos - 1])
    }
    fn vb(&mut self) -> Vec<u8> {
        let mut vector = Vec::with_capacity(8);
        let mut b = false;
        while let Some(c) = self.byte() {
            if !Self::is_whitespace(c) {
                vector.push(c);
                b = true;
            } else if b {
                break;
            }
        }
        vector
    }
}

fn next_permutation<T: Ord + Debug>(vector: &mut [T]) -> bool {
    let n = vector.len();
    for i in (0..n - 1).rev() {
        if vector[i] < vector[i + 1] {
            for j in (i + 1..n).rev() {
                if vector[i] < vector[j] {
                    vector.swap(i, j);
                    break;
                }
            }
            vector[i + 1..n].reverse();
            return true;
        }
    }
    false
}

fn main() {
    let mut input = reader();
    let mut output = writer();
    let mut vector = input.vb();
    vector.sort();
    let mut result = Vec::new();
    result.push(vector.clone());
    while next_permutation(&mut vector) {
        result.push(vector.clone());
    }
    writeln!(output, "{}", result.len()).ok();
    result
        .into_iter()
        .for_each(|r| writeln!(output, "{}", String::from_utf8(r).unwrap()).unwrap());
}