Das deutsche Python-Forum

Code: Alles auswählen

sum([True, False, True])

Code: Alles auswählen

name_des_objekts.iter().sum();

Code: Alles auswählen

use std::{
    fs::File,
    io::{prelude::*, BufReader},
    path::Path
};
extern crate itertools;
use itertools::Itertools;


fn is_safe(report: Vec<i32>) -> bool {
    let mut safe: Vec<bool> = Vec::new();
    for (x, y) in report.into_iter().tuple_windows() {
        if 1 <= x - y && x -y <= 3 {
            safe.push(true);
        } else if 1 <= y - x && y - x <= 3 {
            safe.push(true);
        } else {safe.push(false)}
    };
    safe.iter().all(|&x| x == true)
}


fn get_safe_reports(reports: Vec<Vec<i32>>) -> i32 {
    let safe_reports: Vec<_>= reports.into_iter().map(|report| is_safe(report)).collect();
    safe_reports.iter().sum()
}


fn read_lines(filepath: impl AsRef<Path>) -> Vec<String> {
    let file_content = File::open(filepath).expect("File not found");
    let buffer = BufReader::new(file_content);
    buffer.lines()
        .map(|l| l.expect("Can't read"))
        .collect()
}

fn format_input(lines: Vec<String>) -> Vec<Vec<i32>> {
    let mut reports: Vec<Vec<_>> = Vec::new();
    for line in lines {
        let line = line.split_whitespace().map(|x| x.parse().unwrap()).collect();
        reports.push(line);
    };
    reports

}



fn main() {
    let lines = read_lines("/home/dennis/AoC/2024/src/input02.txt");
    let reports = format_input(lines);
    println!("{:?}", get_safe_reports(reports));
}

Code: Alles auswählen

[dennis@dennis submarine]$ cargo run
   Compiling submarine v0.1.0 (/home/dennis/AoC/submarine)
error[E0277]: a value of type `i32` cannot be made by summing an iterator over elements of type `&bool`
    --> src/main.rs:26:25
     |
26   |     safe_reports.iter().sum()
     |                         ^^^ value of type `i32` cannot be made by summing a `std::iter::Iterator<Item=&bool>`
     |
     = help: the trait `Sum<&bool>` is not implemented for `i32`
     = help: the following other types implement trait `Sum<A>`:
               `i32` implements `Sum<&i32>`
               `i32` implements `Sum`
note: the method call chain might not have had the expected associated types
    --> src/main.rs:25:39
     |
25   |     let safe_reports: Vec<_>= reports.into_iter().map(|report| is_safe(report)).collect();
     |                               ------- ^^^^^^^^^^^ ----------------------------- `Iterator::Item` changed to `bool` here
     |                               |       |
     |                               |       `Iterator::Item` is `Vec<i32>` here
     |                               this expression has type `Vec<Vec<i32>>`
26   |     safe_reports.iter().sum()
     |                  ------ `Iterator::Item` is `&bool` here
note: required by a bound in `std::iter::Iterator::sum`
    --> /home/dennis/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:3578:12
     |
3575 |     fn sum<S>(self) -> S
     |        --- required by a bound in this associated function
...
3578 |         S: Sum<Self::Item>,
     |            ^^^^^^^^^^^^^^^ required by this bound in `Iterator::sum`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `submarine` (bin "submarine") due to 1 previous error

Code: Alles auswählen

use std::{
    fs::File, io::{prelude::*, BufReader}, path::Path
};
extern crate itertools;
use itertools::Itertools;


fn is_safe(report: Vec<i32>) -> bool {
    let mut safe_up: Vec<bool> = Vec::new();
    let mut safe_down: Vec<bool> = Vec::new();
    for (x, y) in report.into_iter().tuple_windows() {
        if 1 <= x - y && x -y <= 3 {
            safe_up.push(true);
        } else {safe_up.push(false)}
        if 1 <= y - x && y - x <= 3 {
            safe_down.push(true);
        } else {safe_down.push(false)}
    };
    safe_up.iter().all(|x| *x) || safe_down.iter().all(|x| *x)
}


fn get_safe_reports(reports: Vec<Vec<i32>>) -> u16 {
    let safe_reports: Vec<_>= reports.into_iter()
        .map(|report| is_safe(report))
        .collect();
    safe_reports.into_iter().filter(|b| *b).count().try_into().unwrap()
}


fn skip_index(iterable: Vec<i32>, index: usize) -> Vec<i32> {
    iterable.into_iter()
        .enumerate()
        .filter(|&(i, _)| i != index)
        .map(|(_, v)| v)
        .collect()
}


fn get_tolerated_safe_reports(reports: Vec<Vec<i32>>) -> u16 {
    let mut safe_reports: u16 = 0;
    for report in reports {
        let mut safe = 0;
        if is_safe(report.clone()) == true {
            safe = 1;
        } else {
            for index in 0..report.len() {
                let optimized_report = skip_index(report.clone(), index);
                if is_safe(optimized_report) == true {
                    safe = 1;
                    break;
                };
            };
        };
        safe_reports += safe;
        };
    safe_reports
    }


fn read_lines(filepath: impl AsRef<Path>) -> Vec<String> {
    let file_content = File::open(filepath).expect("File not found");
    let buffer = BufReader::new(file_content);
    buffer.lines()
        .map(|l| l.expect("Can't read"))
        .collect()
}


fn format_input(lines: Vec<String>) -> Vec<Vec<i32>> {
    let mut reports: Vec<Vec<_>> = Vec::new();
    for line in lines {
        let line = line.split_whitespace().map(|x| x.parse().unwrap()).collect();
        reports.push(line);
    };
    reports

}


fn main() {
    let lines = read_lines("/home/dennis/PycharmProjects/AdventofCode/2024/Day02/input02.txt");
    let reports = format_input(lines);
    println!("{:?}", get_safe_reports(reports.clone()));
    println!("{:?}", get_tolerated_safe_reports(reports));
}

Code: Alles auswählen

In [14]: issubclass(bool, int)
Out[14]: True

In [15]: isinstance(True, bool)
Out[15]: True

In [16]: isinstance(True, int)
Out[16]: True

In [17]: True == 1
Out[17]: True

In [18]: True + 1
Out[18]: 2

In [19]: False == 0
Out[19]: True

In [20]: False - 1
Out[20]: -1

Code: Alles auswählen

>>>0 == ~-1
True
>>>False == ~True
False
>>>~True
-2

Code: Alles auswählen

10 PRINT NOT TRUE
20 PRINT FALSE

RUN
-1
0

READY.

Code: Alles auswählen

fn main() {
    println!(
        "true: {:?}\n
        false: {:?}\n
        ~true: {:?}", 
        true as i32, false as i32, !true as i32
    );
}

Code: Alles auswählen

[dennis@dennis test]$ cargo run
   Compiling test v0.1.0 (/home/dennis/test)
true: 1
false: 0
~true: 0

Code: Alles auswählen

10 T=1=1:F=1<>1
20 PRINT T; NOT T
30 PRINT F; NOT F
RUN
-1  0
 0 -1

READY.

Code: Alles auswählen

enum Bool {
    False,
    True,
}

impl std::ops::Not for Bool {
    type Output = Self;

    fn not(self) -> Self {
        match self {
            Self::False => Self::True,
            Self::True => Self::False,
        }
    }
}

Code: Alles auswählen

fn is_safe(report: &[i32]) -> bool {
    let mut safe_up = true;
    let mut safe_down = true;
    for (x, y) in report.iter().tuple_windows() {
        safe_up &= 1 <= x - y && x - y <= 3;
        safe_down &= 1 <= y - x && y - x <= 3;
    }
    safe_up || safe_down
}

Code: Alles auswählen

fn is_safe(report: &[i32]) -> bool {
    (report.is_sorted() || report.is_sorted_by_key(Reverse))
        && report
            .iter()
            .tuple_windows()
            .all(|(&x, &y)| (1..=3).contains(&x.abs_diff(y)))
}

Code: Alles auswählen

fn get_safe_reports(reports: &[Vec<i32>]) -> usize {
    reports.iter().filter(|report| is_safe(report)).count()
}

Code: Alles auswählen

use itertools::Itertools;
use std::cmp::Reverse;
use std::fs::read_to_string;

fn is_safe(report: &[i32]) -> bool {
    (report.is_sorted() || report.is_sorted_by_key(Reverse))
        && report
            .iter()
            .tuple_windows()
            .all(|(&x, &y)| (1..=3).contains(&x.abs_diff(y)))
}

fn get_safe_reports(reports: &[Vec<i32>]) -> usize {
    reports.iter().filter(|report| is_safe(report)).count()
}

fn skip_index(iterable: &[i32], index: usize) -> Vec<i32> {
    iterable
        .iter()
        .enumerate()
        .filter(|&(i, _)| i != index)
        .map(|(_, v)| *v)
        .collect()
}

fn get_tolerated_safe_reports(reports: &[Vec<i32>]) -> usize {
    reports
        .iter()
        .filter(|report| {
            is_safe(report) || (0..report.len()).any(|index| is_safe(&skip_index(report, index)))
        })
        .count()
}

fn parse_input<'a>(lines: impl Iterator<Item = &'a str>) -> Vec<Vec<i32>> {
    lines
        .map(|line| {
            line.split_whitespace()
                .map(|word| word.parse().unwrap())
                .collect()
        })
        .collect()
}

fn main() {
    let input = read_to_string("input.txt").unwrap();
    let reports = parse_input(input.lines());
    println!("{:?}", get_safe_reports(&reports));
    println!("{:?}", get_tolerated_safe_reports(&reports));
}

Code: Alles auswählen

fn skip_index(iterable: &[i32], index: usize) -> Vec<i32> {
    iterable
        .iter()
        .enumerate()
        .filter(|&(i, _)| i != index)
        .map(|(_, v)| *v)
        .collect()
}

Code: Alles auswählen

fn skip_index(iterable: &[i32], index: usize) -> Vec<i32> {
    iterable
        .into_iter()
        .enumerate()
        .filter(|&(i, _)| i != index)
        .map(|(_, &v)| v)
        .collect()
}

Code: Alles auswählen

fn skip_index(iterable: &[i32], index: usize) -> Vec<i32> {
    let it: impl Iterator<Item = &i32> = iterable.iter();
    let it: impl Iterator<Item = (usize, &i32)> = it.enumerate();
    let it: impl Iterator<Item = (usize, &i32)> = it.filter(|&(i, _): &(usize, &i32)| i != index);
    let it: impl Iterator<Item = i32> = it.map(|(_, &v): (usize, &i32)| v);
    let vec: Vec<i32> = it.collect();
    vec
}

Code: Alles auswählen

pub fn main() {
    let x = 42;
    let ref_x = &x;
    let &deref_via_pattern = ref_x;
    let deref_via_operator = *ref_x;
    dbg!(deref_via_pattern);
    dbg!(deref_via_operator);
}

Code: Alles auswählen

fn main() {
    let x = 5;
    let y = &x;
}

Code: Alles auswählen

.map(|(_, v)| *v)

Code: Alles auswählen

.map(|(_, &v)| v)

Code: Alles auswählen

let it: impl Iterator<Item = (usize, &i32)> = it.filter(|&(i, _): &(usize, &i32)| i != index);

Code: Alles auswählen

struct Number(u64);

fn f(number: Number) {
    let Number(n) = number;
    println!("{n}");
}

Code: Alles auswählen

    it.filter(|&Pair { first: i, second: _ }: &Pair| i != index);