[Sync Track] rust

solutions/rust/acronym/1/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "acronym"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/acronym/1/src/lib.rs

@@ -0,0 +1,25 @@
+fn find_camel_case(word:&str) -> String {
+    let mut camel_case_letter = String::new();
+    let ch_word:Vec<char> =  word.chars().collect();
+    for (index, ch) in ch_word.iter().enumerate() {
+        if let Some(next_ch) = ch_word.get(index+1) {
+            if ch.is_uppercase() && index > 0 && !next_ch.is_uppercase() {
+                camel_case_letter.push(*ch);
+            }
+        }
+    }
+    camel_case_letter
+}
+
+
+pub fn abbreviate(phrase: &str) -> String {
+    let mut acronym = String::new();
+    let word_list:Vec<&str> = phrase.split(&[' ', '-', '_'][..]).map(|word| word.trim()).collect();
+    for word in word_list {
+        if let Some(acr) = word.chars().nth(0) {
+            acronym.push(acr);
+            acronym.push_str(&find_camel_case(word));
+        }
+    }
+    acronym.to_uppercase()
+}

solutions/rust/acronym/2/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "acronym"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/acronym/2/src/lib.rs

@@ -0,0 +1,25 @@
+fn find_camel_case(word:&str) -> String {
+    let mut camel_case_letter = String::new();
+    let ch_word:Vec<char> =  word.chars().collect();
+    for (index, ch) in ch_word.iter().enumerate() {
+        if let Some(next_ch) = ch_word.get(index+1) {
+            if ch.is_uppercase() && index > 0 && !next_ch.is_uppercase() {
+                camel_case_letter.push(*ch);
+            }
+        }
+    }
+    camel_case_letter
+}
+
+
+pub fn abbreviate(phrase: &str) -> String {
+    let mut acronym = String::new();
+    let word_list:Vec<&str> = phrase.split(&[' ', '-', '_'][..]).map(|word| word.trim()).collect();
+    for word in word_list {
+        if let Some(acr) = word.chars().next() {
+            acronym.push(acr);
+            acronym.push_str(&find_camel_case(word));
+        }
+    }
+    acronym.to_uppercase()
+}

solutions/rust/all-your-base/1/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "allyourbase"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/all-your-base/1/src/lib.rs

@@ -0,0 +1,33 @@
+#[derive(Debug, PartialEq, Eq)]
+pub enum Error {
+    InvalidInputBase,
+    InvalidOutputBase,
+    InvalidDigit(u32),
+}
+
+pub fn convert(number: &[u32], from_base: u32, to_base: u32) -> Result<Vec<u32>, Error> {
+    if from_base < 2 {
+        return Err(Error::InvalidInputBase)
+    }
+    if to_base < 2 {
+        return Err(Error::InvalidOutputBase)
+    }
+    let mut value = 0_u128;
+    for &d in number {
+        if d >= from_base {
+            return Err(Error::InvalidDigit(d))
+        }
+        value = value * from_base as u128 + d as u128;
+    }
+    if value == 0 {
+        return Ok(vec![0])
+    }
+    let mut output:Vec<u32> = Vec::new();
+    let mut n  = value;
+    while n > 0 {
+        output.push((n % to_base as u128) as u32);
+        n /= to_base as u128;
+    }
+    output.reverse();
+    Ok(output)
+}

solutions/rust/allergies/1/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "allergies"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/allergies/1/src/lib.rs

@@ -0,0 +1,57 @@
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Allergen {
+    Eggs,
+    Peanuts,
+    Shellfish,
+    Strawberries,
+    Tomatoes,
+    Chocolate,
+    Pollen,
+    Cats,
+}
+
+pub struct Allergies {
+    score: u32,
+}
+
+impl Allergies {
+    pub fn new(score: u32) -> Self {
+        Self { score: score & 0xFF }
+    }
+
+    pub fn is_allergic_to(&self, allergen: &Allergen) -> bool {
+        let mask = Self::allergen_score(allergen);
+        (self.score & mask) != 0
+    }
+
+    pub fn allergies(&self) -> Vec<Allergen> {
+        let all = [
+            Allergen::Eggs,
+            Allergen::Peanuts,
+            Allergen::Shellfish,
+            Allergen::Strawberries,
+            Allergen::Tomatoes,
+            Allergen::Chocolate,
+            Allergen::Pollen,
+            Allergen::Cats,
+        ];
+
+        all.iter()
+            .cloned()
+            .filter(|a| self.is_allergic_to(a))
+            .collect()
+    }
+
+    fn allergen_score(allergen: &Allergen) -> u32 {
+        match allergen {
+            Allergen::Eggs => 1,
+            Allergen::Peanuts => 2,
+            Allergen::Shellfish => 4,
+            Allergen::Strawberries => 8,
+            Allergen::Tomatoes => 16,
+            Allergen::Chocolate => 32,
+            Allergen::Pollen => 64,
+            Allergen::Cats => 128,
+        }
+    }
+}

solutions/rust/anagram/1/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "anagram"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/anagram/1/src/lib.rs

@@ -0,0 +1,24 @@
+use std::collections::{HashSet, HashMap};
+
+pub fn anagrams_for<'a>(word: &str, possible_anagrams: &[&'a str]) -> HashSet<&'a str> {
+    let mut anagram_set:HashSet<&str> = HashSet::new();
+    for possible_word in possible_anagrams {
+        if word.to_lowercase().eq(&possible_word.to_lowercase()) {
+            continue;
+        }
+        if word_freq_map(&word) == word_freq_map(&possible_word) {
+            anagram_set.insert(&possible_word);
+        }else {
+            continue;
+        }
+    }
+    anagram_set
+}
+
+fn word_freq_map(word:&str)-> HashMap<char, usize> {
+    let mut  word_map = HashMap::new();
+    for char in word.to_lowercase().chars() {
+        *word_map.entry(char).or_insert(0) += 1
+    }
+    word_map
+}

solutions/rust/anagram/2/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "anagram"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/anagram/2/src/lib.rs

@@ -0,0 +1,24 @@
+use std::collections::{HashSet, HashMap};
+
+pub fn anagrams_for<'a>(word: &str, possible_anagrams: &[&'a str]) -> HashSet<&'a str> {
+    let mut anagram_set:HashSet<&str> = HashSet::new();
+    for possible_word in possible_anagrams {
+        if word.to_lowercase().eq(&possible_word.to_lowercase()) {
+            continue;
+        }
+        if word_freq_map(word) == word_freq_map(possible_word) {
+            anagram_set.insert(possible_word);
+        }else {
+            continue;
+        }
+    }
+    anagram_set
+}
+
+fn word_freq_map(word:&str)-> HashMap<char, usize> {
+    let mut  word_map = HashMap::new();
+    for char in word.to_lowercase().chars() {
+        *word_map.entry(char).or_insert(0) += 1
+    }
+    word_map
+}

solutions/rust/armstrong-numbers/1/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "armstrong_numbers"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/armstrong-numbers/1/src/lib.rs

@@ -0,0 +1,14 @@
+pub fn is_armstrong_number(num: u32) -> bool {
+    let mut number = 0u32;
+    let num_str = num.to_string();
+    let power  = num_str.len() as u32;
+    for digit_char in num_str.chars() {
+        let digit = digit_char.to_digit(10).unwrap();
+        number += digit.pow(power);
+    }
+    if number == num {
+        true
+    } else {
+        false
+    }
+}

solutions/rust/armstrong-numbers/2/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "armstrong_numbers"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]

solutions/rust/armstrong-numbers/2/src/lib.rs

@@ -0,0 +1,10 @@
+pub fn is_armstrong_number(num: u32) -> bool {
+    let mut number = 0u32;
+    let num_str = num.to_string();
+    let power  = num_str.len() as u32;
+    for digit_char in num_str.chars() {
+        let digit = digit_char.to_digit(10).unwrap();
+        number += digit.pow(power);
+    }
+    number == num
+}

solutions/rust/binary-search/1/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "binary_search"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]
+
+[features]
+generic = []
+
+[lints.clippy]
+needless_borrows_for_generic_args = "allow"

solutions/rust/binary-search/1/src/lib.rs

@@ -0,0 +1,31 @@
+pub fn find<C, T>(array: C, key: T) -> Option<usize>
+where 
+    C : AsRef<[T]>,
+    T:PartialEq + PartialOrd + Copy
+{
+    let slice = array.as_ref();
+    if slice.is_empty() { return None}
+    let mid = (0 + slice.len() - 1) / 2;
+    binary_search(slice, key, mid)
+}
+
+fn binary_search<T:PartialEq + PartialOrd + Copy>(array: &[T], key:T, mut index:usize) -> Option<usize> {
+    let current_mid_index= (0 + array.len() - 1) / 2;
+    let middle_value = array[current_mid_index];
+    let left_list  = &array[..current_mid_index];
+    let right_list = &array[current_mid_index+1..];
+    let left_list_len = left_list.len();
+    let right_list_len = right_list.len();
+    if middle_value == key {
+        return Some(index)
+    } else if key < middle_value && left_list_len > 0 {
+        index  = (0 + left_list_len - 1) / 2;
+        return binary_search(left_list, key, index)
+    } else if key > middle_value && right_list_len > 0 {
+        index  = index + ((0 + right_list_len - 1) / 2) + 1;
+        return binary_search(right_list, key, index)
+    } 
+    else {
+       None
+    }
+}

solutions/rust/binary-search/2/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "binary_search"
+version = "0.1.0"
+edition = "2024"
+
+# Not all libraries from crates.io are available in Exercism's test runner.
+# The full list of available libraries is here:
+# https://github.com/exercism/rust-test-runner/blob/main/local-registry/Cargo.toml
+[dependencies]
+
+[features]
+generic = []
+
+[lints.clippy]
+needless_borrows_for_generic_args = "allow"