Day 2: Gift Shop

Megathread guidelines

  • Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
  • You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://topaz.github.io/paste/ if you prefer sending it through a URL

FAQ

  • CameronDev@programming.devOPM
    4·
    1 month ago

    When you have regex, everything looks like a haystack.

    Nearly solved pt2 by accident in pt1. Just showing the invalid checks, rest of the code is uninteresting.

    fn check_invalid(p0: usize) -> bool {
        let str = format!("{}", p0);
        let len = str.len();
        if len % 2 == 1 {
            return false;
        }
        let len = len / 2;
        str[0..len] == str[len..]
    }

    fn check_invalid2(p0: usize) -> bool {
        let str = format!("{}", p0);
        let re = Regex::new(r"^([0-9]{1,})\1{1,}$").unwrap();
        if re.is_match(str.as_bytes()).unwrap() {
            return true;
        }
        false
    }

    edit: The bot worked as well! With some slight human intervention. Tomorrow might be automatic if we are lucky.

    • CameronDev@programming.devOPM
      3·
      1 month ago

      Regex free solution. Much faster (233ms vs ~4s)

        fn check_invalid3(p0: usize) -> u32 {
        let mut i = 0;
        let mut found_count = 0;
        loop {
            let mut v = p0;
            i += 1;
            let mask = 10_usize.pow(i);
            if mask >= p0 {
                // Mask is larger than input, we have exhausted available matchers.
                return found_count;
            }
            let remainer = v % mask;
            if remainer < 10_usize.pow(i - 1) {
                // Zero prefix, won't be a pattern. (01, 002, etc)
                continue;
            }
            let mut count = 1;
            loop {
                let new_v = v / mask;
                if new_v % mask != remainer {
                    // doesnt repeat.
                    break;
                }
                if new_v / mask == 0 {
                    // has repeated, so we have found at least one pattern. Lets keep going to see if there is a simpler pattern.
                    found_count = count;
                    break;
                }
                count += 1;
                v = new_v;
            }
        }
    }
      • Deebster@programming.devEnglish
        2·
        1 month ago

        Every so often I look for a library that will compile the regex at compile time - iirc, there’s some stuff needing to made const fn before that can happen.

        Last time I used regex, lazy_static was the way to go; I assume that regex can go in OnceCell nowadays.

        • CameronDev@programming.devOPM
          2·
          1 month ago

          I just passed it around, felt easier and rust-like. Compile time would be nice, but I have a vague feeling this would be too restrictive for some regexes/engines?

          • Deebster@programming.devEnglish
            3·
            1 month ago

            Maybe? There’s some deep wizardry shown in some people’s macros so a regex feels fairly basic in comparison.