refactor: structure of each day

12 files changed, 537 insertions, 565 deletions

diff --git a/2025/aa.rs b/2025/aa.rs
deleted file mode 100644
index eea845f..0000000
--- a/2025/aa.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use aoc::read::read;
-
-#[derive(Debug)]
-struct Ring {
-    inner: usize,
-    counter: usize,
-}
-
-impl Ring {
-    fn new() -> Self {
-        Self {
-            inner: 50, // start in 50
-            counter: Default::default(),
-        }
-    }
-
-    const MAX: usize = 99;
-    // minus
-    fn left(&mut self, num: usize) {
-        for _ in 0..num {
-            if self.inner == 0 {
-                self.inner = Self::MAX;
-            } else {
-                self.inner -= 1;
-            }
-        }
-        self.counter();
-    }
-
-    // plus
-    fn right(&mut self, num: usize) {
-        for _ in 0..num {
-            if self.inner == Self::MAX {
-                self.inner = 0;
-            } else {
-                self.inner += 1;
-            }
-        }
-        self.counter();
-    }
-
-    fn counter(&mut self) {
-        if self.inner == 0 {
-            self.counter += 1;
-        }
-    }
-}
-
-pub fn main() {
-    let mut ring = Ring::new();
-    let input = read(
-        "a", '\n',
-    );
-    for i in input {
-        let dir = i
-            .chars()
-            .next()
-            .unwrap();
-        let num = i[1..]
-            .parse()
-            .unwrap();
-
-        match dir {
-            'L' => ring.left(num),
-            'R' => ring.right(num),
-            _ => {}
-        }
-        println!(
-            "{}: {:#?}",
-            num, ring
-        )
-    }
-    println!(
-        "Result: {}",
-        ring.counter
-    );
-}
diff --git a/2025/ab.rs b/2025/ab.rs
deleted file mode 100644
index bafd2ae..0000000
--- a/2025/ab.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use aoc::fetch::fetch;
-
-#[derive(Debug)]
-struct Ring {
-    inner: usize,
-    counter: usize,
-}
-
-impl Ring {
-    fn new() -> Self {
-        Self {
-            inner: 50, // start in 50
-            counter: Default::default(),
-        }
-    }
-
-    const MAX: usize = 99;
-    // minus
-    fn left(&mut self, num: usize) {
-        for _ in 0..num {
-            if self.inner == 0 {
-                self.inner = Self::MAX;
-            } else {
-                self.inner -= 1;
-            }
-            self.counter();
-        }
-    }
-
-    // plus
-    fn right(&mut self, num: usize) {
-        for _ in 0..num {
-            if self.inner == Self::MAX {
-                self.inner = 0;
-            } else {
-                self.inner += 1;
-            }
-            self.counter();
-        }
-    }
-
-    fn counter(&mut self) {
-        if self.inner == 0 {
-            self.counter += 1;
-        }
-    }
-}
-
-pub fn main() {
-    let mut ring = Ring::new();
-    let input = fetch(1, '\n');
-    for i in input {
-        let dir = i
-            .chars()
-            .next()
-            .unwrap();
-        let num = i[1..]
-            .parse()
-            .unwrap();
-
-        match dir {
-            'L' => ring.left(num),
-            'R' => ring.right(num),
-            _ => {}
-        }
-        println!("{}: {:#?}", num, ring)
-    }
-    println!("Result: {}", ring.counter);
-}
diff --git a/2025/ba.rs b/2025/ba.rs
deleted file mode 100644
index 4903ec0..0000000
--- a/2025/ba.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-use aoc::{fetch::fetch, read::read};
-
-struct Checker {
-    first: usize,
-    last: usize,
-}
-
-impl Checker {
-    fn new(first: usize, last: usize) -> Result<Self, ()> {
-        if first
-            .to_string()
-            .chars()
-            .next()
-            .unwrap()
-            == '0'
-        {
-            return Err(());
-        }
-
-        Ok(
-            Self {
-                first,
-                last,
-            },
-        )
-    }
-
-    fn parse_section_naive(num: usize) -> usize {
-        let mut prevs = String::new();
-        let mut ans = 0;
-        for c in num
-            .to_string()
-            .chars()
-        {
-            if prevs.is_empty() || prevs.contains(c) {
-                prevs.push(c);
-            }
-            if !prevs.contains(c) {
-                prevs.clear()
-            }
-            if prevs.len() >= 2
-                && (num
-                    .to_string()
-                    .len()
-                    == 2
-                    || !prevs.contains(c))
-            {
-                ans += prevs
-                    .parse::<usize>()
-                    .unwrap();
-
-                prevs.clear();
-            }
-        }
-        ans
-    }
-
-    // fn parse_section(num: usize) -> usize {
-    //     let mut ans = 0;
-    //     for (i, c) in num
-    //         .to_string()
-    //         .chars()
-    //         .enumerate()
-    //     {
-    //         for j in i..=num
-    //             .to_string()
-    //             .len()
-    //         {
-    //             for k in (j..=num
-    //                 .to_string()
-    //                 .len()
-    //                 / 2)
-    //                 .rev()
-    //             {
-    //                 ans += if num.to_string()[j..=k] == num.to_string()[k..=k +
-    // (j..k).len()] {                     println!(
-    //                         "{} {j} {k}",
-    //                         num.to_string()[j..k].to_string()
-    //                     );
-    //                     num.to_string()[j..=k]
-    //                         .parse::<usize>()
-    //                         .unwrap()
-    //                 } else {
-    //                     0
-    //                 }
-    //             }
-    //         }
-    //     }
-    //     ans
-    // }
-
-    fn parse_section(num: usize) -> usize {
-        let s = num.to_string();
-        if s.len() % 2 != 0 {
-            return 0;
-        }
-        if s[0..s.len() / 2] == s[s.len() / 2..s.len()] {
-            return num;
-        }
-        0
-    }
-
-    fn parse(self) -> usize {
-        let mut ans = 0;
-        for i in self.first..=self.last {
-            ans += Self::parse_section(i);
-        }
-        ans
-    }
-}
-
-pub fn main() {
-    let input = fetch(
-        2, ',',
-    );
-    // let input = read(
-    //     "b", ',',
-    // );
-    let mut ans = 0;
-
-    println!(
-        "{}",
-        Checker::new(
-            998, 1012,
-        )
-        .unwrap()
-        .parse()
-    );
-    println!(
-        "{}",
-        Checker::new(
-            11, 22,
-        )
-        .unwrap()
-        .parse()
-    );
-    // return;
-    for s in input {
-        let s = s.replace(
-            '\n', "",
-        );
-        let split = s.split('-');
-        let first = split
-            .clone()
-            .next()
-            .unwrap()
-            .parse()
-            .unwrap();
-        let last = split
-            .clone()
-            .nth(1)
-            .unwrap()
-            .parse()
-            .unwrap();
-        ans += &Checker::new(
-            first, last,
-        )
-        .unwrap()
-        .parse();
-    }
-    println!("{ans}");
-}
diff --git a/2025/bb.rs b/2025/bb.rs
deleted file mode 100644
index 84d6b31..0000000
--- a/2025/bb.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use aoc::{fetch::fetch, read::read};
-
-struct Checker {
-    first: usize,
-    last: usize,
-}
-
-impl Checker {
-    fn new(first: usize, last: usize) -> Result<Self, ()> {
-        if first
-            .to_string()
-            .chars()
-            .next()
-            .unwrap()
-            == '0'
-        {
-            return Err(());
-        }
-
-        Ok(
-            Self {
-                first,
-                last,
-            },
-        )
-    }
-
-    fn parse_section_naive(num: usize) -> usize {
-        let mut prevs = String::new();
-        let mut ans = 0;
-        for c in num
-            .to_string()
-            .chars()
-        {
-            if prevs.is_empty() || prevs.contains(c) {
-                prevs.push(c);
-            }
-            if !prevs.contains(c) {
-                prevs.clear()
-            }
-            if prevs.len() >= 2
-                && (num
-                    .to_string()
-                    .len()
-                    == 2
-                    || !prevs.contains(c))
-            {
-                ans += prevs
-                    .parse::<usize>()
-                    .unwrap();
-
-                prevs.clear();
-            }
-        }
-        ans
-    }
-
-    // fn parse_section(num: usize) -> usize {
-    //     let mut ans = 0;
-    //     for (i, c) in num
-    //         .to_string()
-    //         .chars()
-    //         .enumerate()
-    //     {
-    //         for j in i..=num
-    //             .to_string()
-    //             .len()
-    //         {
-    //             for k in (j..=num
-    //                 .to_string()
-    //                 .len()
-    //                 / 2)
-    //                 .rev()
-    //             {
-    //                 ans += if num.to_string()[j..=k] == num.to_string()[k..=k +
-    // (j..k).len()] {                     println!(
-    //                         "{} {j} {k}",
-    //                         num.to_string()[j..k].to_string()
-    //                     );
-    //                     num.to_string()[j..=k]
-    //                         .parse::<usize>()
-    //                         .unwrap()
-    //                 } else {
-    //                     0
-    //                 }
-    //             }
-    //         }
-    //     }
-    //     ans
-    // }
-
-    fn parse_section(num: usize) -> usize {
-        let s = num.to_string();
-        let len = s.len();
-        for substr_len in 1..=len / 2 {
-            if len % substr_len == 0 {
-                let first = &s[0..substr_len];
-                if s.as_bytes()
-                    .chunks(substr_len)
-                    .all(|chunk| chunk == first.as_bytes())
-                {
-                    return num;
-                }
-            }
-        }
-        0
-    }
-
-    fn parse(self) -> usize {
-        let mut ans = 0;
-        for i in self.first..=self.last {
-            ans += Self::parse_section(i);
-        }
-        ans
-    }
-}
-
-pub fn main() {
-    let input = fetch(
-        2, ',',
-    );
-    // let input = read(
-    //     "b", ',',
-    // );
-    let mut ans = 0;
-
-    println!(
-        "{}",
-        Checker::new(998, 1012,)
-            .unwrap()
-            .parse()
-    );
-    println!(
-        "{}",
-        Checker::new(11, 22,)
-            .unwrap()
-            .parse()
-    );
-    // return;
-    for s in input {
-        let s = s.replace(
-            '\n', "",
-        );
-        let split = s.split('-');
-        let first = split
-            .clone()
-            .next()
-            .unwrap()
-            .parse()
-            .unwrap();
-        let last = split
-            .clone()
-            .nth(1)
-            .unwrap()
-            .parse()
-            .unwrap();
-        ans += &Checker::new(
-            first, last,
-        )
-        .unwrap()
-        .parse();
-    }
-    println!("{ans}");
-}
diff --git a/2025/ca.rs b/2025/ca.rs
deleted file mode 100644
index 70c395f..0000000
--- a/2025/ca.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use aoc::{fetch::fetch, joltage::Joltage, read::read};
-
-struct JoltageBank {
-    inner: Vec<Joltage>, // optimization: could be fixzed size slice
-}
-
-impl JoltageBank {
-    fn new(inner: Vec<Joltage>) -> Self {
-        Self {
-            inner,
-        }
-    }
-
-    fn get_biggest_two(&mut self) -> usize {
-        let mut res = 0;
-        // Try all pairs of positions (i, j) where i < j
-        // The resulting number is formed by digit at i followed by digit at j
-        for i in 0..self
-            .inner
-            .len()
-        {
-            for j in (i + 1)
-                ..self
-                    .inner
-                    .len()
-            {
-                let max1 = *self.inner[i] as usize;
-                let max2 = *self.inner[j] as usize;
-                let value = max1 * 10 + max2;
-                if value > res {
-                    res = value;
-                }
-            }
-        }
-        res
-    }
-}
-
-pub fn main() {
-    let input = fetch(
-        3, '\n',
-    );
-    // let vec: Vec<Joltage> = "987654321111111"
-    //     .chars()
-    //     .map(
-    //         |c| {
-    //             Joltage::parse(
-    //                 c.to_digit(10)
-    //                     .unwrap() as u8,
-    //             )
-    //             .unwrap()
-    //         },
-    //     )
-    //     .collect();
-    // println!(
-    //     "{:#?}",
-    //     JoltageBank::new(vec).get_max(2)
-    // );
-    // let input = read(
-    //     "c", '\n',
-    // );
-    let mut res = 0;
-    for i in input {
-        if i.is_empty() {
-            break;
-        }
-        let mut vec = Vec::new();
-        for c in i.chars() {
-            vec.push(
-                Joltage::parse(
-                    c.to_digit(10)
-                        .unwrap() as u8,
-                )
-                .unwrap(),
-            );
-        }
-        res += JoltageBank::new(vec).get_biggest_two();
-    }
-    println!("{res}");
-}
diff --git a/2025/cb.rs b/2025/cb.rs
deleted file mode 100644
index e69de29..0000000
--- a/2025/cb.rs
+++ /dev/null
diff --git a/2025/d b/2025/d
new file mode 100644
index 0000000..9486f2a
--- /dev/null
+++ b/2025/d
@@ -0,0 +1,200 @@
+3433224132322232224331231232231222332222224131333331131333222223422234232214231522223253221331123231
+1222232222222313223322332222223323322221225113712423532123211131122223232213122312222242122311232121
+4333222423523533313524542534333525333493263235233222333433156321242333473335522353313753221232423335
+2222226132122612224321222116222231311122122422321132122424242721122233225232223332314322222334223312
+3222322322342232123322222332343222122222133322112222222222132325222234224222322352223221422222222142
+5354763532447627559654555645567443466243454455425444543335464527553456444555564654435347563473367565
+6133213622363263343632223223433421213223222232522323321325331252223323153222326232716132222127264122
+2222212221222222122124121122262113222222222223224112211222221221222222222222231222222232223222112222
+2324452224451522241326432335525421421232222145224522643224441122232522424212343421111252451223222244
+2222222222221512224222223322322541521522828213223824222322234222112212123232122521222222321212322322
+7483434433844442493326454322364133393274424334243792449325354431445422324225432665863731225289631362
+5634214554421238425624233425223147354453753545362612224266323235522445445564713223426114342124645344
+4768374538684554136253521444454516487262435624345545538264545125344377523581936944136595435555235553
+2212112231929226242377231122222135332221222222522148121222524222226222222212124222222222222228264223
+3333223235133332433233233332243333412424113212233333642332333211332331343213213115323331232323332232
+4333332339232223333122132218332323323331233313313432395131332323194122243221221334233242333314234253
+3433232233213222413343422312212243122223223123223212142352142442222331112222142214322221222444322211
+3333582433322253232222234322123234334431234333532173233363324133131322332237233222323235324333234324
+4534432253734226372442345344631635335354543243454145253233332223244332434252444524433326372532742531
+2424122534324113556623365524235533235663223645225335222453424653416653513332365156225674453553455532
+3252733297285323327734225335637733232334222433242314413134122626254625124827263378322666433321872255
+3253122312242233332221322122132312223222222212322222321422223423311224222333221315322223312234222241
+2555143542132242213233265152122232253322533452221242623722224356623122242512221226352122231522463234
+3245223286248343324453963622444249812723422225733322212144223238927292724243612264654531224321444324
+2211232222232322345323221222221215144121223222223222125431722327521224222443312223222352232213223721
+4433217763643333227333259333273122222933631235233283221222643833323433433532523342323373383152233232
+2646184252331386261143192542872223122258216223623213222315246623645315242786222312135353771254245232
+1215653142222226553232154332167644737322124224275111634224718431323212336244444121222256324429122212
+2217222222243222242122123122142222224222223221223422322123152213481222132211122423221221241112231312
+8532382563628412762937226352334333726563323744362832347631842339246166565316653567512395286413222981
+7934847466535792336826584753381564233673638356366665833276314336843363744319525747435374825924765742
+1323242222223222223212426322323222242211221222122222222221222221222222222222222322322522232212232312
+2111632123282218222211231252423142212222332214223214222125322243141222221112222212222263622222343222
+3335133335446366475254323342726444333344332622332114147333433352333532353343332343332443335223312333
+2222443225553253514222232524221432213432542644545333432155414341474413424233232514224233451222255295
+1353334554437343333522337633336535366334534933372232788316385663233643622383577463353933333823522333
+9523453783434333228334731343462442385557453436434436144544443633654282644246657563942427843434367153
+4434433534254456422413634343334254342144443325334433565256454642644355432644333291733454534443136642
+3225211321225424343351322132243323135422423213322222233334523442353321223234425232323221523241452345
+3733564532763485476668535334254555327577554542667433132334363414233473424883867436739763466274589332
+2212222323224232212222313331222222222322322221252232222122232221252332212632232222322132221212231121
+2733225143512222212222222122225515623132222152115225231146117422222212121432236234621422623311252423
+5216234375553476235466755375744442332677325435645233424652432653443367245674223635126655423632227637
+3332222222323312323222221222312132222232122112222222223222122222224222423223241322312231222213222233
+4223244221344443211131421124112244242314411121411334343424332212222223122322322141123212312313456789
+2323122231222221122227222232222216213222222212212127313223411211122821222126422333522232211212842222
+1431542121234272248244324254445643613833472562541238465244574377752358824642277232272342432221324342
+4122416672524684324822643222213826152232365344433716313452323363433441243718636535433575222392625243
+4281261962426425325127613122152232122117121225623222312323712222222221512227417222276252241443533316
+2242212222223622424252422222621245722132263222122222222223421422222243222212212427122212311222222222
+2223221221235222113222235931212132232132222222541322243223213212523222222212122212522221222213123113
+4222224413422322443234312333441222542212234442244234424314142322444441224454242441442313121322122422
+4422255222413124212132262262144114143421334524232632242253522122432342172243355425354736262322222232
+3543565382443323425453544553344565134734493431765543441463334433924534122338133615312142545345524276
+3232214232213132332224221222223323242216243212422222222232222222224121322152321223212224234223232232
+2365224133234443422144154224143242434429221346265341332214332444924424222441846243363431792213344641
+3523515123243131343334133554335313532144413245353235215424544555411334241241214344355441122133336789
+2213223321422212132222221221221212122212231122222232322221212221223222222222222222222222212124221222
+3426653212323321233222266235157621524226214715254435323335712226245422121214222224262422366256224422
+2332322236727422715335382133233252223234322633243246123423524322322422125627212213633271352437164222
+4444216234782442474933774714324264134263433459423688832573247624576617434563344316535337753463345144
+8382464932657242221343629292465155535845432668243332622686938425952926222652556127278327328772335753
+7422564696352416325432315146522234424556595525629646355682558576641554352235622662525266255252622236
+4344622223433553464133668444575332535753632783123425334436553422344153133236238322422352575446122152
+2233213223223132322223123212236232322222341232322233323233222322123232622223233233622222332332233143
+6425774344444134449444533265696774544444458365553317349537334663466476454476542465453353695442644468
+4289665555545366534425442446676655646456544556358563655582462446664461565617234564655554584566556623
+1212113123133233343243313343313234133332122244322221232223422331322322422322112133231342133324222332
+3335423142443333234446433412232243323312435432122334263433334335433234322222241242411422223325342225
+4423422353234365444451454224337314444134241242333311233434434423532313424244624244344413437444424343
+3444444425332452424441453244343155446352215533542244356623314392454222245514224646323322544334231344
+3223742332363523232133323224422324332531333252224322332332221355224223322223332211324223331224415222
+1922212223234412221222222222122121232144128334222232222321211222322222224122212241432141222221224212
+5363323378366639634467263334647754476532644543343569777434537336736427649754233283346337423373348452
+1222254122222323324422482566422322322232361222222555212226332232516114212222234231252223114322421356
+2214122214222163292133222363273322373424612123222223222975222122323332232325342363442333233243341223
+3413244393237332333323339336533338433333243334334332332323213333333323233333512543334365272325353335
+3345383234523225349623334341536333456582313515543453324233663353544746366248343139391243144933363483
+3334243234341233223434443251332413442533131324433383313424321432232213337334634342524423334422322133
+3233342232322332233421314383233223343353332733543433231133233133233333423123233323513353334233246243
+6343234334424256345532434444446415424236743723143634544624944764451646625233254636434846426266943424
+2222122222221222222333236223332222223226222232214331241228262422212222131121321312221322323122114131
+2311222222266322312222232363232622222232724137222221222343223333226364123222432122126323222232421222
+2222234522224322222112612122221212231126122222222222221212122222221122222222232522222213322262322243
+4224231312112324335421344222333332323332321422442116343212323251234424344222422222332323324342222224
+2536114414431223354431251243142534452354145434461452426513516424144331561531425624436155566345413789
+3332333323324233243343524723222333342433323333323333313143314452343233333333233345423133335235342342
+2434334333233562332355335333334133323433373233324633235536363233233354333333333331323335337332373325
+2114562532126255341262558422243655232442426311215241363353235243625242524745225431226234424246436446
+1529233123242224222142323437245232257772133423163924212322959242245312582953221373245434463443222832
+2411221412233622342444213534321224234124533424432423236231231221215242224224444325232332229424232331
+3512112276232243221113321272232312642541227222435826121122322742222222222124131222452264222722212423
+2142542825452224182428212226252524968432282222133451422127227515812262637524212234211234224234544362
+7343313153423244472533326248123212842644147432211433533732333543438251333233376532242533622452286225
+5763746655655654596664968546556396566563663646344667774454657876677572558246578275895536666764655555
+4333245533333332333333233334323423334333331323332133334333223222312322234333343533421242534324333432
+2895344447122123351322424222622422531312442231221532126142423235122233284311334532283222452223232522
+5783452533522623432224464564223213444243664357122444273253217453824354927443242427384274224533695414
+2132121424324331923442234244422218134413441242244244123444222622242824224621244224334234156243442242
+3432232224322221452232322122552324312125112242212222222222222212333122234241532222222223323323211222
+4633374532816262246144574435843222453544744543365556242422548534534525355244845523269256654454414355
+5332422588413621471943212225961264652257255462221715233221162233224463223262632262247234227272231344
+2222112322222222122222232422142132222212222322222222111222218221222232422222422222222122242223222122
+4234241323314421233323223222143342433331142411433342412222233244422266223256323442232342423443312134
+2383533426345745645544444633834254855643466572441631714242233464479645353533642364631648473347384823
+4544754291443422452563134525436658645754445454798583464426564332332446344544464444464445526356533534
+2223212232222122214222252222312122232212412332321322131223136225411213222323322232123321421311122132
+3252322222221312222122623231222352223252242221221232223421222232232227222222424333332222221442222222
+2242432423423114522442322443311274511232762224283212112562142322371234473333334233226172224215321213
+5342121142274252223224227222222222922212332925223322212212221122232221292222231242422228214212422812
+2444744323435355252222325534224534133433434522454413234523325333242424464431453422442324122552243213
+2222135222224273222212212241222222252241922222121242223322223241414523312442522411222221221142235423
+2524212232222323552211222123212224222212124122254435222231223223222331622132224323223252312222222232
+4549594336421422483433447475865457555555228645436545246676421545264355455295443484546465326434965845
+2234253323221222313252123233222424222235213323421322123323222233222322231222322532325322322312233222
+1142244424432412322234424442234412434423332233343324435232244442445244442224224423332242223324342143
+4434424562563936434664664424434447633623444673333344524544169443362656563448932344435448386636146336
+2214352214561224415175322224222542234753465561125225226542222222272342442424323122224112244411227222
+3343431223164433445344467624273733323335644334353354534332326943743234324347363137252234143143335313
+5168522443242444452634425521443247234325441345443516725673443663433433342416751326443434722343342342
+1122224222325435212254246212264334122522523141465351222232222425154536222443623322422213627434323431
+5445353553486566543642825455345471159764966554286557247853446665346433685374355534466653442544683432
+6323764442658934222517416272518643421445244421443254657222218744355462323665423224531434323434357722
+1233232443331212212234233332423232212335332334232333322333233243224223343333333333335222422325432232
+3785532368477552536684244654466667826949344349556645154755863667669166254356449465589757564963644843
+4545264534654415556456565632656454446643654364553535646656476564664346645445654655654544344663556365
+6254675355625255355648645455463566364565394354434453547645537356553986655675856565565436463665563379
+5424334235432216232165434422334335451245294222422253613334934425428225425246523553322343621525454324
+3967965995355651357665464642762467654646594365942576558256558585683569785747725553658425457554456796
+4214222212222232232523413222242222222221222212221134212222262242122242133422234142222142222222123212
+2222613212222222222333212333422223212221252222232112122222222222422212312222224231121311222234221233
+7765382155782246333688635461681314755861622837581142135888542767715185785414274541574368176278451519
+3558783395256623753535432455332667455535756542524242457423563536435746454444652444544673664434167257
+3234332341444332311511243242213224224231434133222222221311321222543241432442224322225223421122123224
+2222232214222322221221221222242224221122122223113322222221222122231122122122212223223242242312232112
+3934174333457547324343343243424334537253442554853465445345444767374393449468334443642443345446433742
+2322231449773252625121172323323825464424722412246245644253282442224333942542446443423232247374247734
+4724353323322263621623354632334433641363335433526435334463462532476873353533236631454312431626454353
+3634543444444444332563423434334434434444443447343443243533344335334324344453444336242444243145533465
+2222241218823324218241212211412124323322211223221242212322242219225132922122429212322223232332232235
+6213251232232222265255122452412262224222224225322622222124242222222223622323222322222236411153212231
+3457656256337756366355554555644345767454554343555556574387874336734733574576255557653957476347455355
+4847674558635766667269532365734596754856756776975755675753588666985396764177668464663834765745277556
+6767342634644663744353672423732232625323353644343284333335232334343387352333388234222342347533434333
+3323523442431544345434534443152333836333433453444334344632423256264934246364336343433454443123443443
+1231231333326634432331225322234261173231551124335236267426322712222223213299236321511423561223521325
+3223323232322233222221321222112122322223323222321112223323321123222431232323524421312232122213232332
+1236326462169437665337532355254333442322283432332542464124343552333433443433236241244633433221353195
+1232232226251721615753276116264362545522264273626321242163725677316432362115553521252266646624566735
+1534233332234222522113233322333232332233222322523232332222213322232221231223123122333222592522222323
+5532545443655447555148455353641354515344154344445343744513555354573335253536564449453242454445431553
+5844946576481457487676456554644744446736738778368544642676756187645567584756443385444782337566757349
+3333343333263633432633333433243331333323365313433332323432232332433313331345234333335343433333332331
+3613263126174952467854432163271757766322573222224258525237333223223312743222323222277143222472843934
+4314443452533536723424221283443253483374332443263323352337295222826423332536163172232623436342437452
+2464555446345533294636573242557544553363733254244324442333255474241324243533323333343333255355353445
+4283344454427439344441434254735343828424335544352344143923444435464334323536447244342395343532475275
+3644444443322322144323232447174134464342515442344334635343457253334231444625384345422444524434244284
+3322162123232522532332122332222521332245322822212322212337328324945223172323322352323876332821342332
+6697525533745634476313367499654656277737669262884135759493246267375196359525737634663761866135295876
+3454752638451678557653755528258533145257478772733365457273325454146234845744542753783351828756889522
+1532554645333237254357247633563523542664322444645335364293993743518239352435943624253234556164784635
+4339532938835876625675567597234756842856413562257677733744437836446232583698337496332474476343699371
+5212423225222424325212341232822212242542112121712463213531142241232835752431725222241142225217622388
+6687265657445674376546597673366649874597987767467863569754843676453464859577855699863756765592954159
+4231343551333234322344223242343422445334334554222312442331324335137523433433223334433234143124433424
+2357776624561345735172164414262364615711315141627441156647723142455527266424246533552641763752176189
+4523322744363474232448633434442214433432323432243234422237314532384334221334533222434233444612222342
+3312222332148333222932123323322333432344333333234233233423435334433342332343385333332423234333433313
+2453632622353554311345524542352533314344827344545344536231115147224614222254433655332254242326446332
+6453342323122433242332232222173322883562121823122322343422313311232522424222234223243132322243393325
+2424442442343222534124443313333626462341457324472442363322414423332243434443311434752424434793346443
+4136443442323544128333353475353344443533345234344335733443463463433433354545354334543243333942133376
+3223326722342332922443212222722732121123323322242722223233311322313131312323221226232242732333332333
+2522531122111212221522212622126222224224342222122322232242841211525342222223221737525424422127132525
+4242414244434424244338344612243224413441363442347144323424412223254434414942233434322223542444422532
+3333333183312232613336342253223222323433333321323132533132333432352323322232334252332322221433333251
+4222155733432345322366515524425242633335224234344423332322523552272153328324245335544434342245451333
+2464224424322331322332414221542335232232325229442322232427423443444332324324322443122432244343713221
+6743263326445655365366633232543567654364325746532672426329616362525576212352736573222432362764341733
+3277374323831212266632366221322125233257332329523342323362252135243634233272326732353222433274422232
+3313446332333522353223352236241443713322231333224235252223232433542333332242243221244123223233334537
+8526735152514738243334732512234212733132232874662625152268335258223276266222624868382263216784751521
+5575675545464555756744448544445335575447375255357455465743415634654446663444426365648458558844553362
+2423452426426234443346434338461334545434385124553642435653453153616345733574338352534344144856344336
+6632637356374523654874926665363336533456695545538636353933265437365344246394344433333634995143347463
+2235532643363334343333453325554243342355145312335553214353353333335355633744323345333335333543334532
+5222521225922222215412226122615222322221219243442252272334642812262425323122223298421225453222424522
+4646132133142332441231142754112323321323333333436334412322222253781278233122343333322233233235461713
+3375761826225752649512525375645327661863624686665435222561257727834535424463522277837422557224522154
+5455225534343363533523564573545454323445445263526453443683444734864512675554345483533755534434156483
+3243634434444733335533342441321418331342426332533434423335374414533323333233323233553243454632473343
+2244222232222256633315222424522116232522242235532222275522231221112224115293552127511271122421342226
+8654645437453554323444544455455525533244553454525534356444455344636615446535555427543545345253525462
+2221121222222222222222213222242222221222222222223222222322222226222222222422422522112223222213232212
+5627585373364365343243413633376333364335373733467363773256663355334332555336331343335536332354341633
+3354345845345446476444346544447545463145854444434443544344245373452245444445742556346243765546555743
+3222123232233223122232222212231554222262215223224421525222224222344115322412423216223225162222242123
+4644626343434532463555743534451556444535525342225366354633666315244424343454454233615225134555554654
+2444352216545122355224492942447515152244455161432542324549291845752525553324354454533245436254745426
diff --git a/2025/d1.rs b/2025/d1.rs
new file mode 100644
index 0000000..48209ef
--- /dev/null
+++ b/2025/d1.rs
@@ -0,0 +1,96 @@
+use aoc::fetch::fetch;
+
+#[derive(Debug)]
+struct Ring {
+    inner: usize,
+    counter: usize,
+}
+
+impl Ring {
+    fn new() -> Self {
+        Self {
+            inner: 50,
+            counter: Default::default(),
+        }
+    }
+
+    const MAX: usize = 99;
+
+    fn left(&mut self, num: usize, count_each_step: bool) {
+        for _ in 0..num {
+            if self.inner == 0 {
+                self.inner = Self::MAX;
+            } else {
+                self.inner -= 1;
+            }
+            if count_each_step {
+                self.check_counter();
+            }
+        }
+        if !count_each_step {
+            self.check_counter();
+        }
+    }
+
+    fn right(&mut self, num: usize, count_each_step: bool) {
+        for _ in 0..num {
+            if self.inner == Self::MAX {
+                self.inner = 0;
+            } else {
+                self.inner += 1;
+            }
+            if count_each_step {
+                self.check_counter();
+            }
+        }
+        if !count_each_step {
+            self.check_counter();
+        }
+    }
+
+    fn check_counter(&mut self) {
+        if self.inner == 0 {
+            self.counter += 1;
+        }
+    }
+}
+
+fn solve(count_each_step: bool) -> usize {
+    let mut ring = Ring::new();
+    let input = fetch(
+        1, '\n',
+    );
+    for i in input {
+        if i.is_empty() {
+            continue;
+        }
+        let dir = i
+            .chars()
+            .next()
+            .unwrap();
+        let num = i[1..]
+            .parse()
+            .unwrap();
+
+        match dir {
+            'L' => ring.left(
+                num,
+                count_each_step,
+            ),
+            'R' => ring.right(
+                num,
+                count_each_step,
+            ),
+            _ => {}
+        }
+    }
+    ring.counter
+}
+
+pub fn part1() -> usize {
+    solve(false)
+}
+
+pub fn part2() -> usize {
+    solve(true)
+}
diff --git a/2025/d2.rs b/2025/d2.rs
new file mode 100644
index 0000000..9c2b060
--- /dev/null
+++ b/2025/d2.rs
@@ -0,0 +1,110 @@
+use aoc::fetch::fetch;
+
+struct Checker {
+    first: usize,
+    last: usize,
+}
+
+impl Checker {
+    fn new(first: usize, last: usize) -> Result<Self, ()> {
+        if first
+            .to_string()
+            .chars()
+            .next()
+            .unwrap()
+            == '0'
+        {
+            return Err(());
+        }
+
+        Ok(
+            Self {
+                first,
+                last,
+            },
+        )
+    }
+
+    fn parse_section_part1(num: usize) -> usize {
+        let s = num.to_string();
+        let len = s.len();
+        for substr_len in 1..=len / 2 {
+            if len % substr_len == 0 {
+                let first = &s[0..substr_len];
+                if s.as_bytes()
+                    .chunks(substr_len)
+                    .all(|chunk| chunk == first.as_bytes())
+                {
+                    return num;
+                }
+            }
+        }
+        0
+    }
+
+    fn parse_section_part2(num: usize) -> usize {
+        let s = num.to_string();
+        if s.len() % 2 != 0 {
+            return 0;
+        }
+        if s[0..s.len() / 2] == s[s.len() / 2..s.len()] {
+            return num;
+        }
+        0
+    }
+
+    fn parse(self, part2: bool) -> usize {
+        let mut ans = 0;
+        for i in self.first..=self.last {
+            ans += if part2 {
+                Self::parse_section_part2(i)
+            } else {
+                Self::parse_section_part1(i)
+            };
+        }
+        ans
+    }
+}
+
+fn run(part2: bool) {
+    let input = fetch(
+        2, ',',
+    );
+    let mut ans = 0;
+
+    for s in input {
+        let s = s.replace(
+            '\n', "",
+        );
+        if s.is_empty() {
+            continue;
+        }
+        let split = s.split('-');
+        let first = split
+            .clone()
+            .next()
+            .unwrap()
+            .parse()
+            .unwrap();
+        let last = split
+            .clone()
+            .nth(1)
+            .unwrap()
+            .parse()
+            .unwrap();
+        ans += &Checker::new(
+            first, last,
+        )
+        .unwrap()
+        .parse(part2);
+    }
+    println!("{ans}");
+}
+
+pub fn part1() {
+    run(false);
+}
+
+pub fn part2() {
+    run(true);
+}
diff --git a/2025/d3.rs b/2025/d3.rs
new file mode 100644
index 0000000..3d56ed6
--- /dev/null
+++ b/2025/d3.rs
@@ -0,0 +1,120 @@
+use aoc::{fetch::fetch, joltage::Joltage, read::read};
+
+struct JoltageBank {
+    inner: Vec<Joltage>,
+}
+
+impl JoltageBank {
+    fn new(inner: Vec<Joltage>) -> Self {
+        Self {
+            inner,
+        }
+    }
+
+    fn get_biggest_two(&mut self) -> usize {
+        let mut res = 0;
+        for i in 0..self
+            .inner
+            .len()
+        {
+            for j in (i + 1)
+                ..self
+                    .inner
+                    .len()
+            {
+                let max1 = *self.inner[i] as usize;
+                let max2 = *self.inner[j] as usize;
+                let value = max1 * 10 + max2;
+                if value > res {
+                    res = value;
+                }
+            }
+        }
+        res
+    }
+
+    fn get_biggest_12(&mut self) -> usize {
+        let digits: Vec<usize> = self
+            .inner
+            .iter()
+            .map(|j| **j as usize)
+            .collect();
+        let n = digits.len();
+        let k = 12;
+        let to_remove = n - k;
+
+        // Use monotonic stack to find largest number by removing `to_remove` digits
+        let mut stack: Vec<usize> = Vec::new();
+        let mut removed = 0;
+
+        for &digit in &digits {
+            while removed < to_remove
+                && !stack.is_empty()
+                && *stack
+                    .last()
+                    .unwrap()
+                    < digit
+            {
+                stack.pop();
+                removed += 1;
+            }
+            stack.push(digit);
+        }
+
+        // If we haven't removed enough, remove from the end
+        while stack.len() > k {
+            stack.pop();
+        }
+
+        let mut res = 0;
+        for val in stack {
+            res = res * 10 + val;
+        }
+        res
+    }
+}
+
+pub fn part1() {
+    let input = fetch(3, '\n');
+    let mut res = 0;
+    for i in input {
+        if i.is_empty() {
+            break;
+        }
+        let mut vec = Vec::new();
+        for c in i.chars() {
+            vec.push(
+                Joltage::parse(
+                    c.to_digit(10)
+                        .unwrap() as u8,
+                )
+                .unwrap(),
+            );
+        }
+        res += JoltageBank::new(vec).get_biggest_two();
+    }
+    println!("{res}");
+}
+
+pub fn part2() {
+    // let input = fetch(3, '\n');
+    let input = read("d", '\n');
+    let mut res = 0;
+    for i in input {
+        if i.is_empty() {
+            break;
+        }
+        let mut vec = Vec::new();
+        for c in i.chars() {
+            vec.push(
+                Joltage::parse(
+                    c.to_digit(10)
+                        .unwrap() as u8,
+                )
+                .unwrap(),
+            );
+        }
+        res += JoltageBank::new(vec).get_biggest_12();
+    }
+    println!("{res}");
+}
diff --git a/2025/fetch.rs b/2025/fetch.rs
index c83d800..6fc7ed7 100644
--- a/2025/fetch.rs
+++ b/2025/fetch.rs
@@ -6,7 +6,13 @@ const YEAR: usize = 2025;
 
 pub fn fetch(lv: usize, p: impl Pattern) -> Vec<String> {
     let jar = Arc::new(Jar::default());
-    jar.add_cookie_str(&format!("session={}", env::var("AOC_SESSION").unwrap()), &Url::parse("https:///adventofcode.com").unwrap());
+    jar.add_cookie_str(
+        &format!(
+            "session={}",
+            env::var("AOC_SESSION").unwrap()
+        ),
+        &Url::parse("https:///adventofcode.com").unwrap(),
+    );
 
     Client::builder()
         .cookie_provider(jar)
diff --git a/2025/main.rs b/2025/main.rs
index 34f5246..350a50d 100644
--- a/2025/main.rs
+++ b/2025/main.rs
@@ -1,15 +1,7 @@
-pub mod aa;
-pub mod ab;
-
-pub mod ba;
-pub mod bb;
-
-pub mod ca;
-pub mod cb;
+pub mod d1;
+pub mod d2;
+pub mod d3;
 
 fn main() {
-    // aa::main();
-    // ab::main();
-    // ba::main();
-    ca::main();
+    d3::part2();
 }