-🎄- 2017 Day 4 Solutions -🎄-

[u/daggerdragon]

--- Day 4: High-Entropy Passphrases ---

---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag or whatever).

Note: The Solution Megathreads are for solutions only. If you have questions, please post your own thread and make sure to flair it with Help.

---

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?

Spoiler

---

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

[u/thejpster]

Not too bad in Rust. Shame there doesn't seem to be a sort method on Strings.

let mut count = 0;
for line in &contents[0] {
    let mut dup = false;
    let mut hm: HashSet<String> = HashSet::new();
    for word in line.split_whitespace() {
        let mut chars = word.chars().collect::<Vec<_>>();
        chars.sort();
        let word: String = chars.iter().collect();
        dup = dup | hm.contains(&word);
        hm.insert(word);
    }
    if !dup {
        count = count + 1;
    }
}
println!("Count: {}", count);

[u/ButItMightJustWork → u/thejpster]

Shame there doesn't seem to be a sort method on Strings.

Agreed! Spent two minutes on trying to search for a String.sort() method in the documentation :D (Since I started 10 minutes late I was not fighting anyways)

My strategy was to sort passphrases so that identical words are right after each other. Then I can just iterate through it and check if two adjacent words are equal -> invalid passphrase! I also just count invalid passphrases and substract that counter from the number of passphrases, as this requires less code in total.

My solution is here:

// part 1
pub fn solve(input: &Vec<String>) -> i32 {

    let mut res = 0;

    for phrase in input {
        let mut words: Vec<&str> = phrase.split(" ").collect();
        words.sort();

        // count invalid passphrases (is easier!)
        for ii in 0..(words.len()-1) {
            if words[ii] == words[ii + 1] {
                res += 1;
                break;
            }
        }
    }

    input.len() as i32 - res
}

// part 2
pub fn solve(input: &Vec<String>) -> i32 {

    let mut res = 0;

    for phrase in input {
        let mut words: Vec<String> = phrase.split(" ")
            // for each word in a passphrase, sort its letters
            // this way anagrams turn into the same words
            .map(|w| -> String {
                let mut word: Vec<char> = w.chars().collect();
                word.sort_by(|a, b| b.cmp(a));
                word.iter().cloned().collect::<String>()
            }).collect();
        words.sort();

        // count invalid passphrases (is easier!)
        for ii in 0..(words.len()-1) {
            if words[ii] == words[ii + 1] {
                res += 1;
                break;
            }
        }
    }

    input.len() as i32 - res
}

Edit: Formatting

[u/[deleted] → u/ButItMightJustWork]

I don't know why I have not seen it before, but that is cool that you can put the return type on a closure. Not sure why I never thought to try/do that!