Das deutsche Python-Forum

Code: Alles auswählen

10 DEFINT A-Z:OPEN"I",#1,"INPUT.TXT":R1=0:R2=0:DI=50
20 WHILE NOT EOF(1):LINE INPUT #1,A$:D$=MID$(A$,1,1):D=VAL(MID$(A$,2))
30 R2=R2+D\100:D=D MOD 100:IF D=0 THEN 70
40 DO=DI:DI=DI+D*((D$="L")*2+1):IF DI=0 THEN R2=R2+1:GOTO 70
50 IF DI<0 THEN DI=DI+100:IF DO<>0 THEN R2=R2+1:GOTO 70
60 IF DI>=100 THEN DI=DI-100:R2=R2+1
70 IF DI=0 THEN R1=R1+1
80 WEND:PRINT R1;R2:SYSTEM

Code: Alles auswählen

use std::fs::read_to_string;

fn instruction_to_int(instruction: &str) -> i32 {
    instruction
        .trim_start_matches("R")
        .replacen("L", "-", 1)
        .parse()
        .unwrap()
}

fn find_path(
    start: i32, instructions: impl Iterator<Item = i32>
) -> impl Iterator<Item = (i32, i32, i32)> {
    let state = (start, 0, 0);
    instructions.scan(state, |(pos, seen_zero, direct_hits), steps| {
        let next_pos = *pos + steps;
        *seen_zero += (next_pos / 100).abs();
        if *pos != 0 && next_pos <= 0 {
            *seen_zero += 1;
        }
        *pos = next_pos.rem_euclid(100);
        if *pos == 0 {
            *direct_hits += 1;
        }
        Some((*pos, *seen_zero, *direct_hits))
    })
}

fn main() {
    let input = read_to_string("input.txt").unwrap();
    let instructions = input.lines().map(instruction_to_int);
    let path = find_path(50, instructions);
    let (_, seen_zero, direct_hits) = path.last().unwrap();
    dbg!(seen_zero, direct_hits);
}

Code: Alles auswählen

from itertools import*;*a,o=open(0);s=str.split;b=map("".join,zip(*a));o=[o.join for o in s(o)]
print(sum(eval(o(a))for o,*a in zip(o,*map(s,a))),sum(eval(o(takewhile(str.strip,b)))for o in o))

Code: Alles auswählen

use std::fs::read_to_string;

struct Zipper<T>(Vec<T>);

impl<T> Iterator for Zipper<T>
where
    T: Iterator,
{
    type Item = Vec<T::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.iter_mut().map(Iterator::next).collect()
    }
}

fn get_total(input: &str) -> i64 {
    let matrix = Zipper(input.lines().map(|line| line.split_whitespace()).collect());
    matrix.map(|column| calculate(&column)).sum()
}

fn calculate(strings: &[&str]) -> i64 {
    let numeric_strings = strings[..strings.len() - 1].iter();
    let numbers = numeric_strings.map(|s| s.parse().unwrap());
    let op = strings[strings.len() - 1];
    numbers.reduce(|a, b| {
        match op {
            "+" => a + b,
            "-" => a - b,
            "*" => a * b,
            "/" => a / b,
            _ => panic!("Unknown operation: {:?}", op),
        }
    }).unwrap()
}

fn main() {
    dbg!(get_total(&read_to_string("input.txt").unwrap()));
}