#![allow(unused_imports)]
#![allow(unused_macros)]

use std::cell::RefCell;
use std::cmp::{max, min, Ordering};
use std::collections::*;
use std::fmt::{Debug, Formatter, Write as FmtWrite};
use std::io::{stderr, stdin, BufRead, Write};
use std::mem::{replace, swap};
use std::ops::*;
use std::rc::Rc;


//
// Macro debug!
//

#[cfg(debug_assertions)]
include!{"./procon/debug.rs"}

#[cfg(not(debug_assertions))]
macro_rules! debug {
    ($($arg:expr),*) => {};
}


//
// Macro input!
//

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}


//
// IteratorExt
//

trait IteratorExt: Iterator + Sized {
    fn vec(self) -> Vec<Self::Item> {
        self.collect()
    }
}

impl<T: Iterator> IteratorExt for T {}


//
// Main
//

// fn main() {
//     input! {
//         cs: chars,
//     }

//     debug!(cs);

//     let ds: Vec<usize> = cs.iter().enumerate().map(|(i, &c)| if c == 'L' { i-1 } else { i+1 }).vec();

//     debug!(ds);

//     let mut a = vec![0; cs.len()];
//     let mut b = vec![1; cs.len()];
//     let mut xs = &mut a;
//     let mut ys = &mut b;

//     let n = if cs.len() % 2 == 0 {
//         cs.len()
//     } else {
//         cs.len() + 1
//     };

//     for _ in 0..n {
//         swap(xs, ys);
//         ys.clear();
//         ys.resize(cs.len(), 0);

//         for i in 0..cs.len() {
//             ys[ds[i]] += xs[i];
//         }
//     }

//     println!("{}", ys.iter().map(|&y| format!("{}", y)).vec().connect(" "));
// }
fn main() {
    input! {
        cs: chars,
    }

    debug!(cs);

    let xs = {
        let mut xs = vec![];

        let mut mode = 'R';
        let mut r = 0;
        let mut s = 0;
        let mut r_pos = 0;

        for (i, &c) in cs.iter().enumerate() {
            if (mode == 'L') && c == 'R' {
                xs.push((r_pos, (r, s)));
                r = 0;
                s = 0;
            }

            if mode != c {
                r_pos = i - 1;
            }

            mode = c;

            match mode {
                'R' => {
                    r += 1;
                },
                'L' => {
                    s += 1;
                },
                _ => panic!(),
            }
        }

        xs.push((r_pos, (r, s)));

        xs
    };

    debug!(xs);

    let ys = xs.iter().map(|&(r_pos, (r, s))| (r_pos, solve(r, s))).vec();
    debug!(ys);
    let mut zs = vec![0; cs.len()];

    for (r_pos, (r, s)) in ys {
        zs[r_pos] = r;
        zs[r_pos + 1] = s;
    }

    println!("{}", zs.iter().map(|&z| format!("{}", z)).vec().connect(" "));
}

fn solve(r: usize, s: usize) -> (usize, usize) {
    let x = (r + s) / 2;
    let n = max(r, s);

    if (max(r, s) - min(r, s)) % 2 == 0 {
        (x, x)
    } else {
        if r < s {
            if n % 2 == 0 {
                (x + 1, x)
            } else {
                (x, x + 1)
            }
        } else {
            if n % 2 == 0 {
                (x, x + 1)
            } else {
                (x + 1, x)
            }
        }
    }
}


Measured memory_bytes: 13936