Adds normalize_line_endings function for input processing

day_5/data/scratch

@@ -0,0 +1,25 @@
+1972667147 405592018 
+1450194064 27782252 
+348350443 61862174 
+3911195009 181169206 
+626861593 138786487 
+2886966111 275299008 
+825403564 478003391 
+514585599 6102091 
+2526020300 15491453 
+3211013652 546191739
+
+
+
+TO LOW:
+6335758
+
+
+New lowest location: 852082781 - from seed: 348350443 (VALID)
+New lowest location: 624704155 - from seed: 368099087 (VALID)
+New lowest location: 462405710 - from seed: 421798005 (INVALID!)
+New lowest location: 123535056 - from seed: 1211303880 (VALID)  -- INCORRECT
+New lowest location: 122300259 - from seed: 1537339145 (INVALID!)
+New lowest location: 102613526 - from seed: 2301593560 (VALID) -- ????
+New lowest location: 44948412 - from seed: 2488220507 (INVALID!)
+New lowest location: 6335758 - from seed: 2837209310 (INVALID!)  -- INCORRECT

day_5/src/main.rs

@@ -6,6 +6,21 @@ use std::{io::prelude::*, fs::File, path::Path, collections::HashMap };
 //				DATA STRUCTS
 /////////////////////////////////////////////////////////////////////
 
+#[derive(Clone, Debug)]
+struct SeedRange
+{
+    start: i64,
+    length: i64,
+}
+
+impl SeedRange
+{
+    fn new(start: i64, length: i64) -> SeedRange
+    {
+        SeedRange { start, length }
+    }
+}
+
 #[derive(Clone, Debug)]
 struct SubMap
 {
@@ -82,7 +97,7 @@ impl Map
 fn main() 
 {
     let input = load_data("data/input");
-    let (seeds, maps) = parse_input(&input);
+    let (seeds, maps, seed_ranges) = parse_input(&input);
 
     // TEST STUFF
     // println!("SEEDS: {:#?}, MAPS: {:#?}", seeds, maps);
@@ -97,6 +112,74 @@ fn main()
 
     let location = find_closest_location(&seeds, &maps);
     println!("Closest location: {}", location);
+
+    let second_loc = find_closest_from_range(&seed_ranges, &maps);
+    println!("Closest location from range: {}", second_loc);
+}
+
+fn find_closest_from_range(seed_ranges: &Vec<SeedRange>, maps: &Vec<Map>) -> i64
+{
+    let mut closest_location = i64::MAX;
+
+    // for seed_range in seed_ranges
+    // {
+    //     println!("Checking seed range: start: {}, length: {}", seed_range.start, seed_range.length);
+
+    //     let start = seed_range.start;
+    //     let end = seed_range.start + seed_range.length + 1;
+    //     for seed in start..end
+    //     {
+    //         let location = find_seed_location(seed, maps);
+
+    //         if location < closest_location
+    //         {
+    //             closest_location = location;
+    //             println!("New lowest location: {}", closest_location);
+    //             // best_seed = *seed;
+    //         }
+    //     }
+    // }
+
+    // OTHER THINGS TO TRY:
+    //  Super brute force but reject any seeds that are not valid (using the is_seed_valid function). 
+    //      Maybe this will include some seeds that were left out before by mistake?
+    //
+    //  
+
+    // SUPER BRUTE FORCE ALL SEED VALUES BETWEEN SMALLEST SEED AND LARGEST SEED (INCLUDES INVALID SEEDS!)
+    let smallest_seed: i64 = 348350443;
+    let largest_seed: i64 =  4092364215 + 1;
+
+    for seed in smallest_seed..largest_seed
+    {
+        let location = find_seed_location(seed, maps);
+
+        if location < closest_location
+        {
+            closest_location = location;
+            let valid = match is_seed_valid(seed, seed_ranges) 
+            {
+                true => "VALID",
+                false => "INVALID!"
+            };
+            println!("New lowest location: {} - from seed: {} ({})", closest_location, seed, valid);
+        }
+    }
+
+    closest_location
+}
+
+fn is_seed_valid(value: i64, seed_ranges: &Vec<SeedRange>) -> bool
+{
+    for range in seed_ranges
+    {
+        if value >= range.start && value <= range.start + range.length
+        {
+            return true;
+        }
+    }
+
+    false
 }
 
 fn find_closest_location(seeds: &Vec<i64>, maps: &Vec<Map>) -> i64
@@ -125,7 +208,7 @@ fn find_seed_location(seed: i64, maps: &Vec<Map>) -> i64
     let mut current_value = seed;
     for map in maps
     {
-        println!("Mapping {}...", map.name);
+        // println!("Mapping {}...", map.name);
         current_value = map.map_input(current_value);
     }
 
@@ -135,9 +218,10 @@ fn find_seed_location(seed: i64, maps: &Vec<Map>) -> i64
 /////////////////////////////////////////////////////////////////////
 //				INPUT PARSING
 /////////////////////////////////////////////////////////////////////
-fn parse_input(input: &str) -> (Vec<i64>, Vec<Map>) // String is the map name
+fn parse_input(input: &str) -> (Vec<i64>, Vec<Map>, Vec<SeedRange>) // String is the map name
 {
     let mut seeds: Vec<i64> = Vec::new();
+    let mut seed_ranges: Vec<SeedRange> = Vec::new();
 
     let mut maps: Vec<Map> = Vec::new();
     let mut current_map = "";
@@ -153,11 +237,22 @@ fn parse_input(input: &str) -> (Vec<i64>, Vec<Map>) // String is the map name
         // SEEDS
         if line.contains("seeds:")
         {
-            println!("Parseing seed input...");
+            println!("Parsing seed input...");
+            let mut start_value: i64 = -1;
             for val in line.trim_start_matches("seeds:").trim().split(" ")
             {
                 let num = val.parse::<i64>().expect(&format!("Failed to parse seed value: {}", val));
                 seeds.push(num);
+
+                if start_value == -1
+                {
+                    start_value = num;
+                }
+                else
+                {
+                    seed_ranges.push(SeedRange::new(start_value, num));
+                    start_value = -1;
+                }
             }
 
             continue;
@@ -179,7 +274,7 @@ fn parse_input(input: &str) -> (Vec<i64>, Vec<Map>) // String is the map name
         // NEW SUB MAP
         let mut sub_map = SubMap::new();
         let vals: Vec<&str> = line.trim().split(" ").collect();
-        println!("Parsing sub map: {}", sub_map_idx);
+        // println!("Parsing sub map: {}", sub_map_idx);
 
         if vals.len() < 3
         {
@@ -204,7 +299,7 @@ fn parse_input(input: &str) -> (Vec<i64>, Vec<Map>) // String is the map name
         // }
     }
 
-    (seeds, maps)
+    (seeds, maps, seed_ranges)
 }
 
 

day_6/.gitignore

@@ -0,0 +1 @@
+/target

day_6/.vscode/launch.json

@@ -0,0 +1,45 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'day_1'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=day_1",
+                    "--package=day_1"
+                ],
+                "filter": {
+                    "name": "day_1",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'day_1'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=day_1",
+                    "--package=day_1"
+                ],
+                "filter": {
+                    "name": "day_1",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

day_6/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "day_6"
+version = "0.1.0"

day_6/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "day_6"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

day_6/build.rs

@@ -0,0 +1,31 @@
+
+use std::{env, fs, path::Path};
+
+fn main()
+{
+    // let out_dir = env::var("OUT_DIR").unwrap();
+    // let cwd = env::var("CARGO_MANIFEST_DIR").unwrap();
+    // println!("CWD: {}\n", cwd);
+    // let data_dir = cwd + "\\data";
+    // let data_path = Path::new(&data_dir);
+    // println!("Data path: {}", data_path.to_string_lossy());
+
+    // let data_path = Path::new("data/test_input");
+
+    let out_path = format!("target/{}", &env::var("PROFILE").unwrap());
+    let out_path = Path::new(&out_path);
+    //let out_path = Path::new(&out_dir).join(&env::var("PROFILE").unwrap());
+    let out_path_data = out_path.join(Path::new("data"));
+
+    if !out_path_data.exists()
+    {
+        fs::create_dir(&out_path_data).expect(&format!("Could not create data directory at: {}", out_path_data.to_string_lossy()));
+    }
+
+    for file in fs::read_dir("data").unwrap()
+    {
+        let file = file.unwrap();
+        let dest = out_path.join(file.path());
+        fs::copy(file.path(), &dest).expect(&format!("Could not copy file {} to {}", file.path().to_string_lossy(), dest.to_string_lossy()));
+    }
+}

day_6/data/input

@@ -0,0 +1,2 @@
+Time:        47     84     74     67
+Distance:   207   1394   1209   1014

day_6/data/test_input

@@ -0,0 +1,2 @@
+Time:      7  15   30
+Distance:  9  40  200

day_6/src/main.rs

@@ -0,0 +1,68 @@
+
+use std::{io::prelude::*, fs::File, path::Path, io };
+
+#[derive(Clone, Debug)]
+struct Race
+{
+    time: i32,
+    record_dist: i32,
+}
+
+fn main() 
+{
+    let input = load_data("data/test_input");
+
+    let races = parse_input(&input);
+}
+
+/////////////////////////////////////////////////////////////////////
+//				LOAD AND PARSE INPUT
+/////////////////////////////////////////////////////////////////////
+
+fn parse_input(input: &str) -> Vec<Race>
+{
+
+    let mut times: Vec<i32> = Vec::new();
+    let mut record_dists: Vec<i32> = Vec::new();
+
+
+
+    Vec::new()
+}
+
+fn load_data(file_name: &str) -> String
+{
+    let mut file = match File::open(Path::new(file_name))
+    {
+        Ok(file) => file,
+        Err(why) => panic!("Could not open file {}: {}", Path::new(file_name).display(), why),
+    };
+
+    let mut s = String::new();
+    let file_contents = match file.read_to_string(&mut s) 
+    {
+        Err(why) => panic!("couldn't read {}: {}", Path::new(file_name).display(), why),
+        Ok(_) => s,
+    };
+    
+    return normalize_line_endings(&file_contents);
+}
+
+fn normalize_line_endings(data: &str) -> String
+{
+    let mut data: Vec<u8> = data.as_bytes().into();
+
+    let mut idx = 0;
+    while idx < data.len()
+    {
+        if data[idx as usize] == b'\r'
+        {
+            data.remove(idx as usize);
+            idx -= 1;
+        }
+
+        idx += 1;
+    }
+
+    String::from_utf8(data).expect("normalize_line_endings - FAILED: string was not valid utf_8")
+}