avec les filtres ça se fait bien (vu que j'avais une colonne par bit), mais heureusement que j'ai eu bon du 1er coup pasque sinon j'aurais pas eu le courage de tout reprendre pour chercher l'erreur

        public string Solve2ndPart()
        {
            var input = Utils.ReadInput("InputDay03.txt" );
            var diagnostic = input.Split(Environment.NewLine);
 
            var oxygenGeneratorRating = 0;
            var co2ScrubberRating = 0;
 
            var diagWindow = diagnostic;
            var pos = 0;
            while (diagWindow.Length > 1)
            {
                diagWindow = GetSubDiag(diagWindow, pos++, true, true);
            }            
            oxygenGeneratorRating = Convert.ToInt32(diagWindow[0], 2);
 
            diagWindow = diagnostic;
            pos = 0;
            while (diagWindow.Length > 1)
            {
                diagWindow = GetSubDiag(diagWindow, pos++, false, false);
            }
            co2ScrubberRating = Convert.ToInt32(diagWindow[0], 2);
 
            var result = oxygenGeneratorRating * co2ScrubberRating;
            return $"{typeof(Day03).Name}:2ndPart Part:{result}";
        }
 
        private string[] GetSubDiag(string[] diagWindow, int diagPos, bool oneOnEquals, bool getActiveBits)
        {
            var result0 = new List<string>();
            var result1 = new List<string>();
 
            diagWindow.ToList().ForEach(diag =>
            {
                if (diag[diagPos] == '1')
                    result1.Add(diag);
                else
                    result0.Add(diag);
            });
 
 
            if (result1.Count == result0.Count)
               return oneOnEquals ? result1.ToArray() : result0.ToArray();
 
 
            if (getActiveBits)
                return result1.Count > result0.Count ? result1.ToArray() : result0.ToArray();
            else
                return result1.Count > result0.Count ? result0.ToArray() : result1.ToArray();
 
 
        }

#include <algorithm>
#include <array>
#include <bitset>
#include <iostream>
#include <iterator>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
 
int main() {
    constexpr const size_t width = 12;
 
    vector<string> numbers;
    std::copy(
        std::istream_iterator<string>(std::cin),  
        std::istream_iterator<string>(),  
        std::back_inserter(numbers)
    );
 
    array<int, width> histogram = accumulate(begin(numbers), end(numbers), array<int, width>{},  
        [](auto histo, const auto& bits) {  
            for (auto i = 0; i < bits.size(); i++) { histo[i] += (bits[i] == '1') ? 1 : 0; }
            return histo;
        }
    );
 
    string gamma(width, '0');
    transform(begin(histogram), end(histogram), begin(gamma),  
        [&](auto i) { return (i < numbers.size()/2) ? '0' : '1'; }
    );
     
    int g = bitset<width>(gamma).to_ulong();
    int e = bitset<width>(gamma).flip().to_ulong();
 
    cout << g * e << endl;
}

auto ox = lines;
for (int i = 0; ox.size() > 1; ++i) {
    auto n = count_if(ox, [i](const auto &l) { return l[i] == '1'; });
    bool more_ones = n >= ox.size() - n;
    ox = ox | filter([i, more_ones](const std::string &l) {
        return more_ones ? l[i] == '1' : l[i] == '0';
    });
}
 
auto co2 = lines;
for (int i = 0; co2.size() > 1; ++i) {
    auto n = count_if(co2, [i](const auto &l) { return l[i] == '1'; });
    bool more_ones = n >= co2.size() - n;
    co2 = co2 | filter([i, more_ones](const std::string &l) {
        return more_ones ? l[i] == '0' : l[i] == '1';
    });
}
 
std::cout << stoi(ox[0], nullptr, 2) * stoi(co2[0], nullptr, 2) << std::endl;

#[inline(always)]
fn count_column(input: &Vec<Vec<u64>>, column_number: usize) -> (usize, usize) {
    let number_of_zeros: usize = input.iter().filter(|c| c.get(column_number) == Some(&0)).count();
    (number_of_zeros, input.len() - number_of_zeros)
}
 
#[inline(always)]
fn to_keep(input: &Vec<Vec<u64>>, position: usize, mut max: usize, keep_zeros: bool) -> Vec<Vec<u64>> {
    input.iter().filter(|c| match c.get(position) {
        Some(value) => if max > 0 && ((keep_zeros && value == &0) || (!keep_zeros && value == &1)) {
            max -= 1;
            true
        } else {
            false
        },
        None => false
    }).map(|c| c.clone()).collect()
}
 
fn aoc_03_part2(input: &Vec<Vec<u64>> ) -> (u64, u64) {
    // Oxygen bullshit
    let mut result: Vec<Vec<u64>> = input.clone();
    // To make sure we never read something not existing...
    let min_column_size: usize = input.iter().map(|row| row.len()).min().unwrap_or(0);
    for i in 0..min_column_size {
        let zero_and_ones: (usize, usize) = count_column(&result, i);
        if zero_and_ones.0 > zero_and_ones.1 {
            result = to_keep(&result, i, zero_and_ones.0, true);
        } else {
            result = to_keep(&result, i, zero_and_ones.1, false);
        }
 
        if result.len() <= 1 {
            break;
        }
    }
    let oxygen_rate: u64 = result.get(0).unwrap_or(&vec![0]).iter().fold(0, |acc, &e| acc << 1 | e);
 
    // CO2 bullshit
    let mut result: Vec<Vec<u64>> = input.clone();
    // To make sure we never read something not existing...
    for i in 0..min_column_size {
        let zero_and_ones: (usize, usize) = count_column(&result, i);
        if zero_and_ones.0 <= zero_and_ones.1 {
            result = to_keep(&result, i, zero_and_ones.0, true);
        } else {
            result = to_keep(&result, i, zero_and_ones.1, false);
        }
 
        if result.len() <= 1 {
            break;
        }
    }
    let co2_scrubber: u64 = result.get(0).unwrap_or(&vec![0]).iter().fold(0, |acc, &e| acc << 1 | e);
 
    (oxygen_rate, co2_scrubber)
}
 
fn aoc_03_part1(input: &Vec<Vec<u64>> ) -> (u64, u64) {
    // To make sure we never read something not existing...
    let min_column_size: usize = input.iter().map(|row| row.len()).min().unwrap_or(0);
    let mut number_of_zeros: usize;
    let mut result: Vec<u64> = Vec::with_capacity(min_column_size);
 
    for i in 0..min_column_size {
        number_of_zeros = count_column(input, i).0;
        // If number of zero is above half of the vector...
        result.push(if 2 * number_of_zeros > input.len() { 0 } else { 1 });
    }
 
    let gamma_rate: u64 = result.iter().fold(0, |acc, &e| acc << 1 | e);
    let epsilon_rate: u64 = result.iter().map(|c| c ^ 1).fold(0, |acc, e| acc << 1 | e);
 
    (gamma_rate, epsilon_rate)
}
 
fn main() {
    // Get the data
    let s: Vec<Vec<u64>> = include_str!("../input.txt" ).lines().filter_map(|s| {
        Some(s.chars().filter_map(|c| c.to_digit(10)).map(|c| c as u64).collect::<Vec<u64>>())
    }).collect::<Vec<Vec<u64>>>();
    // Part 1
    let result = aoc_03_part1(&s);
    println!("Gamma {} Epsilon {} Result {}", result.0, result.1, result.0 * result.1);
    // Part 2
    let result = aoc_03_part2(&s);
    println!("Oxygen {} CO2 {} Result {}", result.0, result.1, result.0 * result.1);
}

https://pastebin.com/X1Nx43Vf

    auto myfilter = [](auto numbers, bool keepMajority) {
        for (int i = 0; numbers.size() > 1; ++i) {
            auto n = r::count_if(numbers, [i](const auto &l) { return l[i] == '1'; });
            const bool more_ones = n >= numbers.size() - n;
            const bool keep_ones = (keepMajority && more_ones) || (!keepMajority && !more_ones);            
            auto criteria = [&i, keep_ones](const std::string &l) {
                return l[i] == (keep_ones ? '1' : '0');
            };
            numbers = numbers | rv::filter(criteria) | r::to<vector<std::string>>;
        }
        return numbers;
    };
 
    auto ox  = myfilter(numbers, true);
    auto co2 = myfilter(numbers, false);