| impl Solution { | |
| // ...stuff... | |
| // Returns a LeetCode linked list from the given vec. | |
| fn vec_to_list(vec: Vec<i32>) -> Option<Box<ListNode>> { | |
| let mut root: Option<Box<ListNode>> = None; | |
| let mut node = &mut root; | |
| for v in vec { | |
| node.replace(Box::new(ListNode::new(v))); | |
| if let Some(n) = node { |
| package main | |
| import "fmt" // for demo, below | |
| type Weekday int | |
| const ( | |
| Sunday Weekday = iota | |
| Monday | |
| Tuesday |
| /* Cargo.toml | |
| [package] | |
| name = "builder-rs" | |
| version = "0.1.0" | |
| edition = "2021" | |
| [dependencies] | |
| typed-builder = "0.16.1" |
| fn main() { | |
| println!( | |
| "{}", | |
| " this is a test of multi-line string, with indents removed\n\ | |
| AND also of using an invisible char (\\u{200b}) to anchor\n\ | |
| the start of text, which allows an indented bullet-list\n\ | |
| \u{200b} - this is a zero-width space\n\ | |
| \u{200b} - this should be indented 4\n\ | |
| ".trim(), | |
| ); |
| /* map-sum vs fold | |
| This code uses map-sum instead of fold. I find map-sum more readable. | |
| In addition, they compile to the same instructions, thus performance | |
| should also be identical. | |
| Ref: https://godbolt.org/z/v73rW3rdd | |
| */ | |
| /// Determine whether the given number is an Armstrong number. | |
| /// | |
| /// An Armstrong number is a number that is the sum of its own digits, |
| mod dsu { | |
| pub struct dsu { | |
| parents: Vec<usize>, | |
| ranks: Vec<usize>, | |
| } | |
| impl dsu { | |
| pub fn new(size: usize) -> Self { | |
| Self { | |
| parents: (0..size).collect(), |
People
 :bowtie: |
😄 :smile: |
😆 :laughing: |
|---|---|---|
😊 :blush: |
😃 :smiley: |
:relaxed: |
😏 :smirk: |
😍 :heart_eyes: |
😘 :kissing_heart: |
😚 :kissing_closed_eyes: |
😳 :flushed: |
😌 :relieved: |
😆 :satisfied: |
😁 :grin: |
😉 :wink: |
😜 :stuck_out_tongue_winking_eye: |
😝 :stuck_out_tongue_closed_eyes: |
😀 :grinning: |
😗 :kissing: |
😙 :kissing_smiling_eyes: |
😛 :stuck_out_tongue: |
| func bitCount(n int) (res int) { | |
| for n > 0 { | |
| if n & 1 == 1 { res++ } | |
| n >>= 1 | |
| } | |
| return | |
| } |
| func PrimeFactors(n int) (res []int) { | |
| // keep dividing by 2 until we arrive at n is odd | |
| for n%2 == 0 { | |
| res = append(res, 2) | |
| n = n / 2 | |
| } | |
| // n is now odd & cannot be even | |
| for i := 3; i*i <= n; i = i + 2 { | |
| for n%i == 0 { |
| /* memoization outside of the function being memoized | |
| The value of this pattern is the modularity of the memoization. | |
| This means that if we change it from a Go map to an external | |
| DB store, then it's just the memo function that needs editing. | |
| Does NOT work with recursive functions. | |
| */ | |
| type FnInt_Int func(int) int |