pub mod simple8b_rle {
/// Simple8b with RLE Encoder
pub struct Encoder;
/// Simple8b with RLE Decoder
pub struct Decoder;
// Constants for selectors, bits per value, and number of values
const SELECTORS: [(u8, usize); 16] = [
// (bits_per_value, num_values)
(0, 240), // Selector 0: 240 zeros
(1, 60), // Selector 1
(2, 30), // Selector 2
(3, 20), // Selector 3
(4, 15), // Selector 4
(5, 12), // Selector 5
(6, 10), // Selector 6
(7, 8), // Selector 7
(8, 7), // Selector 8
(10, 6), // Selector 9
(12, 5), // Selector 10
(15, 4), // Selector 11
(20, 3), // Selector 12
(30, 2), // Selector 13
(60, 1), // Selector 14
(255, 0), // Selector 15: RLE
];
impl Encoder {
/// Creates a new encoder.
pub fn new() -> Self {
Encoder
}
/// Encodes a slice of unsigned 64-bit integers.
pub fn encode(&self, data: &[u64]) -> Vec<u64> {
let mut encoded = Vec::new();
let mut i = 0;
let n = data.len();
while i < n {
// Detect runs of identical values
let mut run_length = 1;
while i + run_length < n && data[i] == data[i + run_length] {
run_length += 1;
}
// Decide whether to use RLE
if run_length >= 3 {
// Use RLE encoding
let value = data[i];
let mut remaining = run_length;
while remaining > 0 {
let rle_run_length = remaining.min(1_048_575); // Max run length in 20 bits
let word = self.encode_rle_word(value, rle_run_length as u32);
encoded.push(word);
remaining -= rle_run_length;
}
i += run_length;
} else {
// Use Simple8b encoding
let mut values = Vec::new();
while i < n && values.len() < 240 {
// Start of a new run
if i + 2 < n && data[i] == data[i + 1] && data[i] == data[i + 2] {
break;
}
values.push(data[i]);
i += 1;
}
let encoded_words = self.encode_simple8b_values(&values);
encoded.extend(encoded_words);
}
}
encoded
}
fn encode_rle_word(&self, value: u64, run_length: u32) -> u64 {
// Selector 15 for RLE
let mut word = 15u64 << 60;
// Encode run_length (20 bits)
word |= ((run_length as u64) & 0xFFFFF) << 40;
// Encode value (40 bits)
word |= value & 0xFFFFFFFFFF;
word
}
fn encode_simple8b_values(&self, values: &[u64]) -> Vec<u64> {
let mut result = Vec::new();
let mut index = 0;
while index < values.len() {
let mut best_selector = None;
// Try all selectors from most to least efficient
for (selector, &(bits_per_value, num_values)) in SELECTORS.iter().enumerate().take(15) {
let max_value = if bits_per_value == 0 { 0 } else { (1u64 << bits_per_value) - 1 };
let end = (index + num_values).min(values.len());
let can_pack = values[index..end].iter().all(|&v| v <= max_value);
if can_pack {
let mut word = (selector as u64) << 60;
for &v in &values[index..end] {
word <<= bits_per_value;
word |= v;
}
result.push(word);
index += end - index;
best_selector = Some(selector);
break;
}
}
// If no suitable selector found, use selector 14 (60 bits per value)
if best_selector.is_none() {
let word = (14u64 << 60) | (values[index] & 0x0FFFFFFFFFFFFFFF);
result.push(word);
index += 1;
}
}
result
}
}
impl Decoder {
/// Creates a new decoder.
pub fn new() -> Self {
Decoder
}
/// Decodes a slice of encoded unsigned 64-bit integers.
pub fn decode(&self, data: &[u64]) -> Vec<u64> {
let mut decoded = Vec::new();
for &word in data {
let selector = (word >> 60) as u8;
match selector {
0 => {
// Zeros
let zero_count = 240;
decoded.extend(std::iter::repeat(0u64).take(zero_count));
}
1..=14 => {
let (bits_per_value, num_values) = SELECTORS[selector as usize];
let mut temp = word;
let mut values = Vec::with_capacity(num_values);
for _ in 0..num_values {
let value = temp & ((1u64 << bits_per_value) - 1);
values.push(value);
temp >>= bits_per_value;
}
values.reverse();
decoded.extend(values);
}
15 => {
// RLE
let run_length = ((word >> 40) & 0xFFFFF) as usize; // 20 bits
let value = word & 0xFFFFFFFFFF; // 40 bits
decoded.extend(std::iter::repeat(value).take(run_length));
}
_ => panic!("Invalid selector: {}", selector),
}
}
decoded
}
}
}
fn main() {
use simple8b_rle::{Decoder, Encoder};
let data = vec![
5, 5, 5, 5, 5, // Run of fives
1, 2, 3, // Non-repeating values
0, 0, 0, 0, // Run of zeros
100, 100, 100, // Run of hundreds
];
let encoder = Encoder::new();
let encoded = encoder.encode(&data);
let decoder = Decoder::new();
let decoded = decoder.decode(&encoded);
assert_eq!(data, decoded);
println!("Original data: {:?}", data);
println!("Encoded data: {:?}", encoded);
println!("Decoded data: {:?}", decoded);
}
Write, Run & Share Rust code online using OneCompiler’s Rust online compiler for free. It’s a fast, interactive, and powerful environment to learn and experiment with the Rust programming language. OneCompiler runs the latest stable version of Rust.
Rust is a systems programming language developed by Mozilla that focuses on performance, memory safety, and concurrency. It guarantees memory safety without a garbage collector and is widely used for system-level programming, web assembly, and command-line tools. Rust's compiler enforces strict compile-time checks, making code safer and more predictable.
The following is a simple Rust program that prints a greeting:
fn main() {
println!("Hello, OneCompiler!");
}
OneCompiler’s Rust editor supports stdin. Here’s a sample program that reads a line of input and prints it:
use std::io;
fn main() {
let mut input = String::new();
io::stdin()
.read_line(&mut input)
.expect("Failed to read line");
println!("Hello, {}", input.trim());
}
let name = "OneCompiler"; // Immutable
let mut age = 25; // Mutable
| Type | Description |
|---|---|
| i32, i64 | Signed integers |
| f32, f64 | Floating-point numbers |
| bool | true or false |
| char | Single character |
| String | Growable string |
let score = 85;
if score >= 50 {
println!("Pass");
} else {
println!("Fail");
}
for i in 1..=5 {
println!("{}", i);
}
let mut i = 1;
while i <= 5 {
println!("{}", i);
i += 1;
}
let mut count = 0;
loop {
if count == 3 {
break;
}
println!("{}", count);
count += 1;
}
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn greet(name: &str) {
println!("Hello, {}!", name);
}
This guide provides a quick reference to Rust programming syntax and features. Start coding in Rust using OneCompiler’s Rust online compiler today!