Word Count

config.json

@@ -826,7 +826,7 @@
         "uuid": "5fded933-439a-4faa-bfb6-18ec7b7c8469",
         "practices": [],
         "prerequisites": [],
-        "difficulty": 1
+        "difficulty": 4
       },
       {
         "slug": "knapsack",

exercises/practice/word-count/.meta/example.cairo

@@ -1,27 +1,57 @@
-use core::dict::Felt252Dict;
-
+#[derive(Debug, PartialEq, Clone, Drop)]
+pub struct WordResult {
+    pub word: ByteArray,
+    pub count: u64,
+}
 
-// word_count returns the dictionary of frequency of words based on the input phrase.
-pub fn word_count(phrase: ByteArray) -> Felt252Dict<u64> {
-    let mut result: Felt252Dict<u64> = Default::default();
+pub fn count_words(phrase: ByteArray) -> Span<WordResult> {
+    let mut results: Array<WordResult> = ArrayTrait::new();
     let words = split_phrase_into_words(phrase);
 
-    let mut arr_to_felt: Array<felt252> = ArrayTrait::new();
-
     let mut i = 0;
     while i < words.len() {
-        arr_to_felt.append(bytearray_to_felt252(words[i]));
+        let mut found = false;
+
+        let mut j = 0;
+        while j < results.len() {
+            if results[j].word == words[i] {
+                let updated_result = WordResult {
+                    word: results[j].word.clone(), count: *results[j].count + 1,
+                };
+
+                results = remove_index_from_array(results, j);
+                results.append(updated_result);
+                found = true;
+                break;
+            }
+            j += 1;
+        };
 
-        let frequency = result.get(*arr_to_felt[i]);
-        result.insert(*arr_to_felt[i], frequency + 1);
+        if !found {
+            let word_and_count = WordResult { word: words[i].clone(), count: 1 };
+            results.append(word_and_count);
+        }
 
         i += 1;
     };
 
-    result
+    results.span()
+}
+
+fn remove_index_from_array(arr: Array<WordResult>, index: u32) -> Array<WordResult> {
+    let mut new_arr: Array<WordResult> = ArrayTrait::new();
+
+    let mut i = 0;
+    while i < arr.len() {
+        if i != index {
+            new_arr.append(arr[i].clone());
+        }
+        i += 1;
+    };
+
+    new_arr
 }
 
-// split phrase into words
 fn split_phrase_into_words(phrase: ByteArray) -> Array<ByteArray> {
     let mut words: Array<ByteArray> = ArrayTrait::new();
     let mut current_word = "";
@@ -32,15 +62,14 @@ fn split_phrase_into_words(phrase: ByteArray) -> Array<ByteArray> {
         if is_alphanumeric_or_apostrophe(lower_case) {
             current_word.append_byte(lower_case);
         } else if current_word.len() > 0 {
-            current_word = split_apostrophe_from_word(current_word); // all checks happen here
+            current_word = split_apostrophe_from_word(current_word);
             words.append(current_word);
             current_word = "";
         }
 
         i += 1;
     };
 
-    // Final word check after the loop
     if current_word.len() > 0 {
         current_word = split_apostrophe_from_word(current_word);
         words.append(current_word);
@@ -49,27 +78,26 @@ fn split_phrase_into_words(phrase: ByteArray) -> Array<ByteArray> {
     words
 }
 
-// Trim apostrophes at the start or end or both sides of the current word
 fn split_apostrophe_from_word(mut current_word: ByteArray) -> ByteArray {
     let mut i = 0;
     let mut new_word = "";
     while i < current_word.len() {
         if current_word[0] == '\'' && current_word[current_word.len() - 1] == '\'' {
             if i > 0 && current_word[i] == '\'' && i < current_word.len() - 1 {
-                new_word.append_byte(get_value(current_word.at(i)));
+                new_word.append_byte(current_word.at(i).unwrap_or(0));
             } else if current_word[i] != '\'' {
-                new_word.append_byte(get_value(current_word.at(i)));
+                new_word.append_byte(current_word.at(i).unwrap_or(0));
             }
         } else if current_word[0] == '\'' {
             if i != current_word.len() - 1 {
-                new_word.append_byte(get_value(current_word.at(i + 1)));
+                new_word.append_byte(current_word.at(i + 1).unwrap_or(0));
             }
         } else if current_word[current_word.len() - 1] == '\'' {
             if current_word[i] != '\'' {
-                new_word.append_byte(get_value(current_word.at(i)));
+                new_word.append_byte(current_word.at(i).unwrap_or(0));
             }
         } else {
-            new_word.append_byte(get_value(current_word.at(i)));
+            new_word.append_byte(current_word.at(i).unwrap_or(0));
         }
 
         i += 1;
@@ -78,41 +106,14 @@ fn split_apostrophe_from_word(mut current_word: ByteArray) -> ByteArray {
     new_word
 }
 
-// get u8 value from an option
-fn get_value(option: Option<u8>) -> u8 {
-    match option {
-        Option::Some(value) => value, // Extracts and returns the u8 value
-        Option::None => {
-            // Handle None case appropriately; here we return a default of 0
-            0
-        }
-    }
-}
-
-// convert byteArray to felt252
-fn bytearray_to_felt252(words: @ByteArray) -> felt252 {
-    let mut result: felt252 = 0;
-
-    let mut i = 0;
-    while i < words.len() {
-        let byte: u8 = words[i];
-
-        result = result * 256 + (byte.into());
-        i += 1;
-    };
-
-    result
-}
-
-fn is_alphanumeric_or_apostrophe(char: u8) -> bool {
-    // Check if character is alphanumeric or an apostrophe
-    ('0' <= char && char <= '9') || ('a' <= char && char <= 'z') || ('A' <= char && char <= 'Z') || char == '\''
+fn is_alphanumeric_or_apostrophe(ch: u8) -> bool {
+    ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || ch == '\''
 }
 
-fn to_lowercase(char: u8) -> u8 {
+fn to_lowercase(ch: u8) -> u8 {
     // Convert ASCII uppercase letters to lowercase
-    if 'A' <= char && char <= 'Z' {
-        char + 32 // Convert to lowercase by ASCII offset
+    if 'A' <= ch && ch <= 'Z' {
+        ch + 32 // Convert to lowercase by ASCII offset
     } else {
         ch
     }

exercises/practice/word-count/Scarb.toml

@@ -0,0 +1,7 @@
+[package]
+name = "word_count"
+version = "0.1.0"
+edition = "2024_07"
+
+[dev-dependencies]
+cairo_test = "2.8.2"

exercises/practice/word-count/src/lib.cairo

@@ -1,3 +1,3 @@
-pub fn word_count(phrase: ByteArray) -> Felt252Dict<u64> {
-    panic!("implement `word_count`")
-}
+pub fn count_words(phrase: ByteArray) -> Span<WordResult> {
+    panic!("implement `count_words`")
+}