Learning Rust and improving with Codewars solutions
One of the frustrations with learning from some text books is that they set vague exercises at the end of a chapter without being explicit in the nature of the task and therefore no solution either….
For example “Write a function to convert text to ascii”
Codewars
Replace With Alphabet Position
I’ve started to use Codewars as a tool to help brush up on the “cleverest” ways to solve a problem. The term “cleverest” being based upon peer recognition.
I’ve picked this example : https://www.codewars.com/kata/546f922b54af40e1e90001da/rust
My attempt…(Which does work)
fn alphabet_position(text: &str) -> String {
let alphabet = String::from("abcdefghijklmnopqrstuvwxyz");
let mut retvec: Vec<u8> = Vec::new();
for c in text.to_ascii_lowercase().chars() {
let f = alphabet.find(c);
let res = match f {
Some(v) => v as u8 + 1,
_ => 0,
};
if res > 0 {
retvec.push(res);
};
}
let stuff_str: String = retvec
.iter()
.map(ToString::to_string)
.collect::<Vec<String>>()
.join(" ");
stuff_str
}The ‘Cleverest’ solution:
Here is the top rated solution.
So even from first glance I can see there was no need to create the “alphabet” on line 2, I could have used filter and map with closures…and used “chars” to create an iterable rather than a for loop. Much more idiomatic as well?
Why the u32 – 96 ?
Once the char is lower case, you can subtract 96 to find it’s corresponding numeric value giving a = 1, b =2, and so on.
Check out the ASCII reference
Even with my long winded solution I worked out that to remove the quotes around each of the numbers you can use
".join(" ")fn alphabet_position(text: &str) -> String {
text.to_lowercase()
.chars()
.filter(|c| c >= &'a' && c <= &'z')
.map(|c| (c as u32 - 96).to_string())
.collect::<Vec<String>>()
.join(" ")
}Check out the code in the Rust Playground here
After solving this I was able to learn by checking the ‘best’ solution, and I’m going to try the next one which arguably is more difficult, especially in Rust.
The next Rust challenge – “The Supermarket Queue”
The is is the link to the “shopping queue” problem. I’ll update this post in due course, as I want to solve it before checking the solution(s).
My initial idea is to identify the 3 main scenarios, and use this code for starters :
Firstly, Scenario 1 is where there is 1 queue
Secondly, Scenario 2 is where the number of tills is the same or greater than the number of customers
Finally, Scenario 3 is where there are more customers than tills
1 and 2 are “Easy” to solve.
3 is not so straightforward and this is where the double ended queue “Deque” will help, with the use of “pop_front”
Check back soon for a working solution and a comparison against the “best” solution.
In the meantime, here’s my experimental code gist: https://gist.github.com/6d49285fa7b079ad16ea79f7305a44e5
Rust Solution = (Work-in-progress)
| // https://www.codewars.com/kata/57b06f90e298a7b53d000a86/train/rust | |
| use std::collections::VecDeque; | |
| // A double-ended queue implemented with a growable ring buffer. | |
| use std::iter::FromIterator; | |
| fn queue_time(customers: &[u32], n: u32) -> u32 { | |
| let mut deq = VecDeque::from_iter(customers); | |
| let clen = customers.len(); // 3 | |
| println!("number of customers = {}", clen); | |
| let tills = n; | |
| println!("number of tills = {}\n", tills); // 2 | |
| // --------------------------------------------------------------------------------- | |
| let mut outer_vec: Vec<Vec<usize>> = Vec::new(); | |
| let mut inner_vec: Vec<usize> = Vec::new(); | |
| for _ in 0..n { | |
| inner_vec.push(2); | |
| } | |
| // inner_vec and outer_vec are now in the same scope, so this is fine: | |
| outer_vec.push(inner_vec); | |
| println!("\nouter vec = {:?}", outer_vec); | |
| // --------------------------------------------------------------------------------- | |
| for (i, x) in customers.iter().enumerate() { | |
| println!("In position {} we have value {}", i, x); | |
| } | |
| if tills == 1 { | |
| return customers.iter().sum(); | |
| }; | |
| if tills >= clen as u32 { | |
| let max = customers.iter().max().unwrap(); | |
| return *max; | |
| } | |
| if tills < clen as u32 { | |
| let remainder = customers[1..].iter().sum(); | |
| println!("\nremainder = {}\n ", &remainder); | |
| if deq[0] > &remainder { | |
| println!("Deque 1 {}", deq[0]); | |
| println!("Deque 2 {}", deq[1]); | |
| } | |
| let ret = deq.pop_front().unwrap(); | |
| return *ret; | |
| } | |
| 0 | |
| } | |
| fn main() { | |
| let res = queue_time(&[96, 22, 33, 40], 2); | |
| println!("\n{res}"); | |
| } | |
| /*queueTime([5,3,4], 1) | |
| // should return 12 | |
| // because when there is 1 till, the total time is just the sum of the times | |
| queueTime([10,2,3,3], 2) | |
| // should return 10 | |
| // because here n=2 and the 2nd, 3rd, and 4th people in the | |
| // queue finish before the 1st person has finished. | |
| queueTime([2,3,10], 2) | |
| // should return 12 | |
| */ | |
| // fn fixed_tests() { | |
| // dotest(&[], 1, 0); | |
| // dotest(&[5], 1, 5); | |
| // dotest(&[2], 5, 2); | |
| // dotest(&[1, 2, 3, 4, 5], 1, 15); | |
| // dotest(&[1, 2, 3, 4, 5], 100, 5); | |
| // dotest(&[2, 2, 3, 3, 4, 4], 2, 9); | |
| // } | |
| /* | |
| There is a queue for the self-checkout tills at the supermarket. Your task is write a function to calculate the total time required for all the customers to check out! | |
| input | |
| customers: an array of positive integers representing the queue. Each integer represents a customer, and its value is the amount of time they require to check out. | |
| n: a positive integer, the number of checkout tills. | |
| output | |
| The function should return an integer, the total time required. | |
| */ |
by Python Working Solution:
| ls =([8,3,5,5,2,1],3) | |
| queue = ls[0] | |
| print(f"queue = {queue}") | |
| # reverse to allow use of 'pop' | |
| queue.reverse() | |
| print(f"reversed queue = {queue}") | |
| print(f"max value in queue = {max(queue)}") | |
| ntills = ls[1] | |
| print (f"number of tills = {ntills}") | |
| queue_depth = len(queue) | |
| print(f"queue depth = {queue_depth}") | |
| # ----------------------------------- | |
| def r(queue, ntills)->int: | |
| dct = {} | |
| for i in range(0,ntills): | |
| dct["till_"+str(i+1)] = 0 | |
| if queue_depth <= ntills: | |
| return min(queue) | |
| else: | |
| while len(queue) >=1: | |
| minim = min(dct.values()) | |
| # find till with shortest queue | |
| resk = [key for key in dct if dct[key] == minim] | |
| # pop the next customer and update the till queue they'e been added to | |
| dct[resk[0]] +=(queue.pop()) | |
| result = min(dct.values()) | |
| return result | |
| # result is till with shortest queue | |
| print(r(queue, ntills)) |
VecDeque
If you want to know more about double ended queues and circular buffers, check the Rust Docs and this example:
https://doc.rust-lang.org/std/collections/struct.VecDeque.html#examples-14
Collections in Rust
If you want to know which type of collection would be suitable have a look at the Rust comparison here:
