Das deutsche Python-Forum

Code: Alles auswählen

for operations in  iproduct!(multible_operations.clone(), multible_operations)
    {
        let mut values = values.iter();
        let mut result: u64 = *values.next().unwrap();
        for (operation, value) in operations.zip(values) {
            let result_: u64 = operation(&result, value);
            result = result_;
        }
        if result == *target {
            return true;
        }
    }

Code: Alles auswählen

error[E0599]: `(fn(&u64, &u64) -> u64, ...)` is not an iterator
  --> src/main.rs:42:46
   |
42 |         for (operation, value) in operations.zip(values) {
   |                                              ^^^ `(fn(&u64, &u64) -> u64, ...)` is not an iterator
   |

Code: Alles auswählen

s = 10989.60064
print(f"{s} s")
m = s / 60
print(f"{m} min")
h = m / 60
print(f"{h} h")
-->
10989.60064 s
183.16001066666666 min
3.0526668444444445 h

Code: Alles auswählen

use itertools::Itertools;
use std::error::Error;
use std::fs::read_to_string;
use std::iter::repeat_n;
use std::time::Instant;

type Operations = [fn(&u64, &u64) -> u64; 2];

fn add(a: &u64, b: &u64) -> u64 {
    a + b
}

fn multiply(a: &u64, b: &u64) -> u64 {
    a * b
}

fn parse_lines<'a>(
    lines: impl Iterator<Item = &'a str>,
) -> Result<Vec<(u64, Vec<u64>)>, Box<dyn Error>> {
    lines
        .map(|line| {
            let (target, operands) = line.split_once(": ").ok_or("No colon in line")?;
            let operands = operands
                .split(' ')
                .map(|operand| operand.parse())
                .collect::<Result<Vec<_>, _>>()?;
            Ok((target.parse()?, operands))
        })
        .collect()
}

fn check_calibration(target: &u64, values: &[u64], operations: &Operations) -> bool {
    for operations in repeat_n(operations, values.len() - 1).multi_cartesian_product() {
        let mut values = values.iter();
        let mut result: u64 = *values.next().unwrap();
        for (operation, value) in operations.iter().zip_eq(values) {
            let result_: u64 = operation(&result, value);
            result = result_;
            if result > *target {
                break;
            }
        }
        if result == *target {
            return true;
        }
    }
    false
}

fn sum_solvable_calibrations(calibrations: &Vec<(u64, Vec<u64>)>, operations: &Operations) -> u64 {
    let mut solvable: Vec<u64> = Vec::new();
    for (target, values) in calibrations {
        if check_calibration(target, values, operations) {
            solvable.push(*target);
        };
    }
    solvable.iter().sum()
}

fn main() {
    let input =
        read_to_string("/home/dennis/PycharmProjects/AdventofCode/2024/Day07/input07.txt").unwrap();
    let calibrations_result = parse_lines(input.lines());
    let calibrations = match calibrations_result {
        Ok(values) => values,
        Err(error) => panic!("Error: {error:?}"),
    };
    let operations: Operations = [add, multiply];
    let start = Instant::now();
    let sum_ = sum_solvable_calibrations(&calibrations, &operations);
    println!("{:?}", sum_);
    println!("{:.5?} runtime", start.elapsed());
}

Code: Alles auswählen

56.29204ms runtime

Code: Alles auswählen

for _ in 0..10 {
    println!("hello world");
}

Code: Alles auswählen

type Operations = Box<[fn(&u64, &u64) -> u64]>;

Code: Alles auswählen

type Operations = [fn(&u64, &u64) -> u64];


fn main() {
    let operations: &Operations = &[add, multiply];
}

Code: Alles auswählen

10 DEFINT A-Z:DIM V#(12):R1#=0
20 OPEN "I",#1,"INPUT.TXT"
30 WHILE NOT EOF(1):LINE INPUT #1,L$:PRINT L$
40 I=INSTR(L$,":"):IF I=0 THEN PRINT"missing ':'":CLOSE 1:END
50 T#=VAL(LEFT$(L$,I)):N=0:I=I+2
60 J=INSTR(I,L$," "):IF J=0 THEN 80
70 N=N+1:V#(N)=VAL(MID$(L$,I,J-I)):I=J+1:GOTO 60
80 N=N+1:V#(N)=VAL(MID$(L$,I))
90 FOR I=0 TO 2^(N-1)-1:X#=V#(1):M=1:FOR J=2 TO N
100 IF I AND M THEN X#=X#+V#(J) ELSE X#=X#*V#(J)
110 M=M+M:NEXT:IF X#=T# THEN R1#=R1#+T#:I=2^(N-1)
120 NEXT:WEND:CLOSE 1:PRINT R1#:SYSTEM