Cargo.toml

@@ -4,5 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+base64 = "0.22.1"
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0"

src/lib.rs

@@ -1 +1,2 @@
+mod tasks;
 mod utils;

src/tasks/mod.rs

@@ -0,0 +1 @@
+mod tasks01;

src/tasks/tasks01/block2poly.rs

@@ -0,0 +1,7 @@
+use crate::utils::poly;
+use base64::prelude::*;
+
+fn block2poly(block: String) {
+    let num_block: u128 = BASE64_STANDARD.decode(block).unwrap().into();
+    let coefficients = poly::get_bit_indices_from_byte();
+}

src/tasks/tasks01/mod.rs

@@ -0,0 +1,2 @@
+mod poly2block;
+mod block2poly;

src/tasks/tasks01/poly2block.rs

@@ -0,0 +1,7 @@
+use crate::utils::poly::{self, coefficient_to_binary};
+use base64::prelude::*;
+use serde_json::Value;
+
+pub fn poly2block(coefficients: Vec<u8>) -> String {
+    BASE64_STANDARD.encode(poly::coefficient_to_binary(coefficients).to_ne_bytes())
+}

src/utils/mod.rs

@@ -1,2 +1,2 @@
-mod parse;
-mod poly;
+pub mod parse;
+pub mod poly;

src/utils/parse.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 
 #[derive(Serialize, Deserialize)]
 pub struct Testcases {
@@ -9,12 +10,5 @@ pub struct Testcases {
 pub struct Testcase {
     uuid: String,
     action: String,
-    arguments: Vec<Argument>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Argument {
-    uuid: String,
-    action: String,
-    arguments: Vec<Argument>,
+    arguments: Value,
 }

src/utils/poly.rs

@@ -1,4 +1,5 @@
 use std::{fmt::format, str::FromStr, u128, u8};
+use base64::prelude::*;
 
 pub fn get_alpha_rep(num: u128) -> String {
     let mut powers: Vec<u32> = vec![];
@@ -25,22 +26,59 @@ pub fn get_alpha_rep(num: u128) -> String {
     alpha_rep
 }
 
+pub fn get_bit_indices_from_byte(byte: u8) -> Vec<u8> {
+    let mut coefficients: Vec<u8> = vec![];
+    
+    for shift in 0..7 {
+        if ((byte >> shift) & 1) == 1 {
+            coefficients.push(shift);
+        }
+    }
+
+    coefficients
+}
+
+pub fn coefficient_to_binary(coefficients: Vec<u8>) -> u128{
+    let mut binary_number: u128 = 0;
+    for coeff in coefficients {
+        binary_number = binary_number | (1<<coeff);
+    }
+
+    binary_number
+}
+
+
 #[cfg(test)]
 mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
 
     #[test]
-    fn test_num_to_alpha_rep_1() {
-        let number: u128 = 0x010000000000000000000000000000000;
-        let polynomial: &str = "1";
-        assert_eq!(get_alpha_rep(number.reverse_bits()), polynomial);
+    fn byte_indices_0x01() {
+        let byte: u8 = 0x01;
+        let bit_indices: Vec<u8> = vec![0];
+        assert_eq!(get_bit_indices_from_byte(byte), bit_indices)
     }
 
     #[test]
-    fn test_num_to_alpha_rep_a4a2a() {
-        let number: u128 = 0x16000000000000000000000000000000;
-        let polynomial: &str = "a^4a^2a";
-        assert_eq!(get_alpha_rep(number.reverse_bits()), polynomial);
+    fn byte_indices_0x23() {
+        let byte: u8 = 0x23;
+        let bit_indices: Vec<u8> = vec![0, 1, 5];
+        assert_eq!(get_bit_indices_from_byte(byte), bit_indices)
+    }
+
+    #[test]
+    fn byte_indices_0x56() {
+        let byte: u8 = 0x56;
+        let bit_indices: Vec<u8> = vec![1, 2, 4, 6];
+        assert_eq!(get_bit_indices_from_byte(byte), bit_indices)
+    }
+
+    #[test]
+    fn coeff_to_binary() {
+        let coefficients: Vec<u8> = vec![12, 127, 9, 0];
+        let b64: &str = "ARIAAAAAAAAAAAAAAAAAgA==";
+        let calculated_num: u128 = coefficient_to_binary(coefficients);
+        assert_eq!(BASE64_STANDARD.encode(calculated_num.to_ne_bytes()), "ARIAAAAAAAAAAAAAAAAAgA==");
     }
 }