Day 2: Red-Nosed Reports

Megathread guidelines

  • Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
  • You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://blocks.programming.dev if you prefer sending it through a URL

FAQ

  • @Quant@programming.dev
    link
    fedilink
    14 days ago

    Uiua

    Took me a bit longer to get this one but still quite simple overall.
    Spent quite some time on getting to know the try and assert operators better.

    Run with example input here

    # Get the indices matching the ascending/
    # descending criteria
    CheckAsc ← ≡°□⍚(⍣(⊸⍤.≍⍆.)⍣(⊸⍤.≍⇌⍆.)0)
    # Get the indices matching the distance criteria
    CheckDist ← ≡°□⍚(⍣(⊸⍤.≠1∈:0)0×⊓≥≤1,3⌵⧈-)
    Split     ← ⊙(▽≠1)▽,,
    
    PartOne ← (
      &rs&fo "input-2.txt"
      ⊜(□⊜⋕≠@ .)≠@\n.
      CheckAsc.
      ▽
      CheckDist
      ⧻⊚
    )
    
    PartTwo ← (
      &rs&fo "input-2.txt"
      ⊜(□⊜⋕≠@ .)≠@\n.
      CheckAsc.
      Split
      CheckDist.
      Split
      ⊙(⊂)
      ⧻
      :
      ⍚(≡(▽:°⊟)⍜¤⊞⊟:≠1⊞=.⇡⧻.)
      ≡(⧻⊚CheckDist▽CheckAsc.°□)
      +⧻◴⊚
    )
    
    &p "Day 2:"
    &pf "Part 1: "
    &p PartOne
    &pf "Part 2: "
    &p PartTwo
    
  • @aurele@sh.itjust.works
    link
    fedilink
    16 days ago

    Elixir

    defmodule AdventOfCode.Solution.Year2024.Day02 do
      use AdventOfCode.Solution.SharedParse
    
      @impl true
      def parse(input) do
        for line <- String.split(input, "\n", trim: true),
            do: String.split(line) |> Enum.map(&String.to_integer/1)
      end
    
      def part1(input) do
        Enum.count(input, &is_safe(&1, false))
      end
    
      def part2(input) do
        Enum.count(input, &(is_safe(&1, true) or is_safe(tl(&1), false)))
      end
    
      def is_safe([a, b, c | rest], can_fix) do
        cond do
          (b - a) * (c - b) > 0 and abs(b - a) in 1..3 and abs(c - b) in 1..3 ->
            is_safe([b, c | rest], can_fix)
    
          can_fix ->
            is_safe([a, c | rest], false) or is_safe([a, b | rest], false)
    
          true ->
            false
        end
      end
    
      def is_safe(_, _), do: true
    end
    
  • lwhjp
    link
    910 days ago

    Haskell

    This was quite fun! I got a bit distracted trying to rewrite safe in point-free style, but I think this version is the most readable. There’s probably a more monadic way of writing lessOne as well, but I can’t immediately see it.

    safe xs = any gradual [diffs, negate <$> diffs]
      where
        diffs = zipWith (-) (drop 1 xs) xs
        gradual = all (`elem` [1 .. 3])
    
    lessOne [] = []
    lessOne (x : xs) = xs : map (x :) (lessOne xs)
    
    main = do
      input :: [[Int]] <- map (map read . words) . lines <$> readFile "input02"
      print . length $ filter safe input
      print . length $ filter (any safe . lessOne) input
    
    • @VegOwOtenks@lemmy.world
      link
      fedilink
      English
      410 days ago

      Love to see your haskell solutions!

      I am so far very amazed with the compactness of your solutions, your lessOne is very much mind-Bending. I have never used or seen <$> before, is it a monadic $?

      Also I can’t seem to find your logic for this safety condition: The levels are either all increasing or all decreasing, did you figure that it wasn’t necessary?

      • For the last point, it isn’t needed since the differences between elements should be all positive or all negative for the report to be safe. This is tested with the combination of negate and gradual.

        I am also enjoying these Haskell solutions. I’m still learning the language, so it’s been cool to compare my solution with these and grow my understanding of Haskell.

      • lwhjp
        link
        19 days ago

        Thanks! The other two posters already answered your questions, I think :)

        Haskell makes it really easy to build complex operations out of simple functional building blocks, skipping a lot of boilerplate needed in some other languages. I find the compactness easier to read, but I realize that not everyone would agree.

        BTW, I’m a relative Haskell newbie. I’m sure more experienced folks could come up with even more interesting solutions!

  • @sjmulder
    link
    59 days ago

    C

    First went through the input in one pass, number by number, but unfortunately that wouldn’t fly for part 2.

    Code
    #include "common.h"
    
    static int
    issafe(int *lvs, int n, int skip)
    {
    	int safe=1, asc=0,prev=0, ns=0,i;
    
    	for (i=0; safe && i<n; i++) {
    		if (i == skip)
    			{ ns = 1; continue; }
    		if (i-ns > 0)
    			safe = safe && lvs[i] != prev &&
    			    lvs[i] > prev-4 && lvs[i] < prev+4;
    		if (i-ns == 1)
    			asc = lvs[i] > prev;
    		if (i-ns > 1)
    			safe = safe && (lvs[i] > prev) == asc;
    
    		prev = lvs[i];
    	}
    
    	return safe;
    }
    
    int
    main(int argc, const char **argv)
    {
    	char buf[64], *rest, *tok;
    	int p1=0,p2=0, lvs[16],n=0, i;
    
    	if (argc > 1)
    		DISCARD(freopen(argv[1], "r", stdin));
    
    	while ((rest = fgets(buf, sizeof(buf), stdin))) {
    		for (n=0; (tok = strsep(&rest, " ")); n++) {
    			assert(n < (int)LEN(lvs));
    			lvs[n] = (int)strtol(tok, NULL, 10);
    		}
    
    		for (i=-1; i<n; i++)
    			if (issafe(lvs, n, i))
    				{ p1 += i == -1; p2++; break; }
    	}
    
    	printf("02: %d %d\n", p1, p2);
    }
    

    https://github.com/sjmulder/aoc/blob/master/2024/c/day02.c

    • @Faresh@lemmy.ml
      link
      fedilink
      English
      29 days ago

      What is this coding style? The function type, name and open brace placement made me think GNU at first, but the code in the body doesn’t look like GCS at all.

      • @sjmulder
        link
        29 days ago

        BSD more or less. Mostly K&R except for function declarations.

  • @mykl@lemmy.world
    link
    fedilink
    5
    edit-2
    9 days ago

    Uiua

    Uiua is still developing very quickly, and this code uses the experimental tuples function, hence the initial directive.

    Try it Live!

    # Experimental!
    "7 6 4 2 1\n1 2 7 8 9\n9 7 6 2 1\n1 3 2 4 5\n8 6 4 4 1\n1 3 6 7 9"
    ⊜(⊜⋕⊸≠@\s)⊸≠@\n # Partition at \n, then at space, parse ints.
    
    IsSorted ← +⊃(≍⇌⍆.|≍⍆.)        # Compare with sorted array.
    IsSmall  ← /××⊃(>0|<4)⌵↘¯1-↻1. # Copy offset by 1, check diffs.
    IsSafe   ← ×⊃IsSmall IsSorted  # Safe if Small steps and Ordered.
    IsSafer  ← ±/+≡IsSafe ⧅<-1⧻.   # Choose 4 from 5, check again.
    
    &p/+≡IsSafe .            # Part1 : Is each row safe?
    &p/+≡(±+⊃IsSafe IsSafer) # Part2 : Is it safe or safer?
    
      • @mykl@lemmy.world
        link
        fedilink
        49 days ago

        Haha, you can do it that way, in fact the online Uiua Pad editor has all the operators listed along the top.

        But all the operators have ascii names, so you can type e.g. IsSmall = reduce mul mul fork(>0|<4) abs drop neg 1 - rot 1 dup and the formatter will reduce that to IsSmall ← /××⊃(>0|<4)⌵↘¯1-↻1. whenever you save or execute code.

        That works in the Pad, and you can enable similar functionality in other editors.

        • @popcar2@programming.dev
          link
          fedilink
          49 days ago

          I like to assume people using array programming languages just have a crystal ball that they use to call upon magic runes on the screen

      • @mykl@lemmy.world
        link
        fedilink
        18 days ago

        Yes, it should do. I do run the solutions against the live data, but sometimes tweak the solutions afterwards, so can’t always guarantee them :-). I left the comment as 5 choose 4 as it felt clearer in the context of the test data.

        It does still feel very alien at times, but I do love being able to think about how to adopt a more arrays-based approach to solving these problems.

  • @Gobbel2000@programming.dev
    link
    fedilink
    English
    59 days ago

    Rust

    The function is_sorted_by on Iterators turned out helpful for compactly finding if a report is safe. In part 2 I simply tried the same with each element removed, since all reports are very short.

    fn parse(input: String) -> Vec<Vec<i32>> {
        input.lines()
            .map(|l| l.split_whitespace().map(|w| w.parse().unwrap()).collect())
            .collect()
    }
    
    fn is_safe(report: impl DoubleEndedIterator<Item=i32> + Clone) -> bool {
        let safety = |a: &i32, b: &i32| (1..=3).contains(&(b - a));
        report.clone().is_sorted_by(safety) || report.rev().is_sorted_by(safety)
    }
    
    fn part1(input: String) {
        let reports = parse(input);
        let safe = reports.iter().filter(|r| is_safe(r.iter().copied())).count();
        println!("{safe}");
    }
    
    fn is_safe2(report: &[i32]) -> bool {
        (0..report.len()).any(|i| {  // Try with each element removed
            is_safe(report.iter().enumerate().filter(|(j, _)| *j != i).map(|(_, n)| *n))
        })
    }
    
    fn part2(input: String) {
        let reports = parse(input);
        let safe = reports.iter().filter(|r| is_safe2(r)).count();
        println!("{safe}");
    }
    
    util::aoc_main!();
    
    • Deebster
      link
      fedilink
      English
      29 days ago

      is_sorted_by is new to me, could be very useful.

    • Sleepless One
      link
      fedilink
      English
      29 days ago

      The is_sorted_by is a really nice approach. I originally tried using that function thinking that |a, b| a > b or |a, b| a < b would cut it but it didn’t end up working. I never thought to handle the check for the step being between 1 and 3 in the callback closure for that though.

  • @VegOwOtenks@lemmy.world
    link
    fedilink
    510 days ago

    Haskell

    runningDifference :: [Int] -> [Int]
    runningDifference (a:[]) = []
    runningDifference (a:b:cs) = a - b : (runningDifference (b:cs))
    
    isSafe :: [Int] -> Bool
    isSafe ds = (all (> 0) ds || all (< 0) ds) && (all (flip elem [1, 2, 3] . abs) ds) 
    
    isSafe2 :: [Int] -> Bool
    isSafe2 ds = any (isSafe2') (zip [0..length ds] (cycle [ds]))
    
    isSafe2' (i, ls) = isSafe . runningDifference $ list
            where
                    list = dropIndex i ls
    
    dropIndex _ []     = []
    dropIndex 0 (a:as) = dropIndex (-1) as
    dropIndex i (a:as) = a : dropIndex (i - 1) as
    
    main = do
            c <- getContents
            let reports = init . lines $ c
            let levels  = map (map read . words) reports :: [[Int]]
            let differences = map runningDifference levels
            let safety = map isSafe differences
            let safety2 = map isSafe2 levels
    
            putStrLn . show . length . filter (id) $ safety
            putStrLn . show . length . filter (id) $ safety2
    
            return ()
    

    Took me way too long to figure out that I didn’t have to drop one of them differences but the initial Number

  • @Nighed@feddit.uk
    link
    fedilink
    English
    4
    edit-2
    9 days ago

    #Rust

    initially, for part two I was trying to ignore a bad pair not a bad value - read the question!

    Only installed Rust on Sunday, day 1 was a mess, today was more controlled. Need to look at some of the rust solutions for std library methods I don’t know about.

    very focussed on getting it to actually compile/work over making it short or nice!

    long!

    `

    pub mod task_2 {

    pub fn task_1(input: &str) -> i32{
        let mut valid_count = 0;
    
        let reports = process_input(input);
    
        for report in reports{
            let valid = is_report_valid(report);
    
            if valid{
                valid_count += 1;
            }
        }
    
        println!("Valid count: {}", valid_count);
        valid_count
    }
    
    pub fn task_2(input: &str) -> i32{
        let mut valid_count = 0;
    
        let reports = process_input(input);
    
        for report in reports{
            let mut valid = is_report_valid(report.clone());
    
            if !valid
            {
                for position_to_delete in 0..report.len()
                {
                    let mut updated_report = report.clone();
                    updated_report.remove(position_to_delete);
                    valid = is_report_valid(updated_report);
    
                    if valid { break; }
                }
            }
    
            if valid{
                valid_count += 1;
            }
        }
    
        println!("Valid count: {}", valid_count);
        valid_count
    }
    
    fn is_report_valid(report:Vec<i32>) -> bool{
        let mut increasing = false;
        let mut decreasing = false;
        let mut valid = true;
    
        for position in 1..report.len(){
            if report[position-1] > report[position]
            {
                decreasing = true;
            }
            else if report[position-1] < report[position]
            {
                increasing = true;
            }
            else
            {
                valid = false;
                break;
            }
    
            if (report[position-1] - report[position]).abs() > 3
            {
                valid = false;
                break;
            }
    
            if increasing && decreasing
            {
                valid = false;
                break;
            }
        }
    
        return valid;
    }
    
    pub fn process_input(input: &str) -> Vec<Vec<i32>>{
        let mut reports: Vec<Vec<i32>> = Vec::new();
        for report_string in input.split("\n"){
            let mut report: Vec<i32> = Vec::new();
            for value in report_string.split_whitespace() {
                report.push(value.parse::<i32>().unwrap());
            }
            reports.push(report);
        }
    
        return reports;
    }
    

    }

    `

  • janAkali
    link
    fedilink
    English
    4
    edit-2
    10 days ago

    Nim

    Got correct answer for part 1 on first try, but website rejected it. Wasted some time debugging and trying different methods. Only to have the same answer accepted minutes later. =(

    proc isSafe(report: seq[int]): bool =
      let diffs = collect:
        for i, n in report.toOpenArray(1, report.high): n - report[i]
      (diffs.allIt(it > 0) or diffs.allIt(it < 0)) and diffs.allIt(it.abs in 1..3)
    
    proc solve(input: string): AOCSolution[int, int] =
      let lines = input.splitLines()
      var reports: seq[seq[int]]
      for line in lines:
        reports.add line.split(' ').map(parseInt)
    
      for report in reports:
        if report.isSafe():
          inc result.part1
          inc result.part2
        else:
          for t in 0..report.high:
            var mReport = report
            mReport.delete t
            if mReport.isSafe():
              inc result.part2
              break
    

    Codeberg repo

  • Ananace
    link
    fedilink
    49 days ago

    Of course I ended up with a off-by-one error for the second part, so things took a bit longer than they really should’ve.

    But either way, behold, messy C#:

    C#
    int[][] reports = new int[0][];
    
    public void Input(IEnumerable<string> lines)
    {
      reports = lines.Select(l => l.Split(' ').Select(p => int.Parse(p)).ToArray()).ToArray();
    }
    
    public void Part1()
    {
      int safeCount = reports.Where(report => CheckReport(report)).Count();
      Console.WriteLine($"Safe: {safeCount}");
    }
    public void Part2()
    {
      int safeCount = reports.Where(report => {
        if (CheckReport(report))
          return true;
    
        for (int i = 0; i < report.Length; ++i)
          if (CheckReport(report.Where((_, j) => j != i)))
            return true;
    
        return false;
      }).Count();
    
      Console.WriteLine($"Safe: {safeCount}");
    }
    
    bool CheckReport(IEnumerable<int> report)
    {
      var diffs = report.SkipLast(1).Zip(report.Skip(1)).Select(v => v.Second - v.First);
      return diffs.All(v => Math.Abs(v) <= 3) && (diffs.All(v => v > 0) || diffs.All(v => v < 0));
    }
    
  • @Andy@programming.dev
    link
    fedilink
    4
    edit-2
    7 days ago

    Factor

    : get-input ( -- reports )
      "vocab:aoc-2024/02/input.txt" utf8 file-lines
      [ split-words [ string>number ] map ] map ;
    
    : slanted? ( report -- ? )
      { [ [ > ] monotonic? ] [ [ < ] monotonic? ] } || ;
    
    : gradual? ( report -- ? )
      [ - abs 1 3 between? ] monotonic? ;
    
    : safe? ( report -- ? )
      { [ slanted? ] [ gradual? ] } && ;
    
    : part1 ( -- n )
      get-input [ safe? ] count ;
    
    : fuzzy-reports ( report -- reports )
      dup length <iota> [ remove-nth-of ] with map ;
    
    : tolerable? ( report -- ? )
      { [ safe? ] [ fuzzy-reports [ safe? ] any? ] } || ;
    
    : part2 ( -- n )
      get-input [ tolerable? ] count ;
    
  • Sleepless One
    link
    fedilink
    English
    39 days ago

    Rust

    use crate::utils::read_lines;
    
    pub fn solution1() {
        let reports = get_reports();
        let safe_reports = reports
            .filter(|report| report.windows(3).all(window_is_valid))
            .count();
    
        println!("Number of safe reports = {safe_reports}");
    }
    
    pub fn solution2() {
        let reports = get_reports();
        let safe_reports = reports
            .filter(|report| {
                (0..report.len()).any(|i| {
                    [&report[0..i], &report[i + 1..]]
                        .concat()
                        .windows(3)
                        .all(window_is_valid)
                })
            })
            .count();
    
        println!("Number of safe reports = {safe_reports}");
    }
    
    fn window_is_valid(window: &[usize]) -> bool {
        matches!(window[0].abs_diff(window[1]), 1..=3)
            && matches!(window[1].abs_diff(window[2]), 1..=3)
            && ((window[0] > window[1] && window[1] > window[2])
                || (window[0] < window[1] && window[1] < window[2]))
    }
    
    fn get_reports() -> impl Iterator<Item = Vec<usize>> {
        read_lines("src/day2/input.txt").map(|line| {
            line.split_ascii_whitespace()
                .map(|level| {
                    level
                        .parse()
                        .expect("Reactor level is always valid integer")
                })
                .collect()
        })
    }
    

    Definitely trickier than yesterday’s. I feel like the windows solution isn’t the best, but it was what came to mind and ended up working for me.

  • @ystael@beehaw.org
    link
    fedilink
    39 days ago

    J

    There is probably a way to write this more point-free. You can definitely see here the friction involved in the way J wants to regard lists as arrays: short rows of the input matrix are zero padded, so you have to snip off the padding before you process each row, and that means you can’t lift some of the operations back up to the parent matrix because it will re-introduce the padding as it reshapes the result; this accounts for a lot of the "1 everywhere (you can interpret v"1 as “force the verb v to operate on rank 1 subarrays of the argument”).

    data_file_name =: '2.data'
    data =: > 0 ". each cutopen toJ fread data_file_name
    
    NB. {. take, i. index of; this removes trailing zeros
    remove_padding =: {.~ i.&amp;0
    
    NB. }. behead, }: curtail; this computes successive differences
    diff =: }. - }:
    
    NB. a b in_range y == a &lt;: y &lt;: b
    in_range =: 4 : '(((0 { x) &amp; &lt;:) * (&lt;: &amp; (1 { x))) y'
    
    NB. a row is safe if either all successive differences are in [1..3] or all in [_3.._1]
    NB. +. or
    ranges =: 2 2 $ 1 3 _3 _1
    row_safe =: (+./"1) @: (*/"1) @: (ranges &amp; (in_range"1 _)) @: diff @: remove_padding
    
    result1 =: +/ safe"1 data
    
    NB. x delete y is y without the xth element
    delete =: 4 : '(x {. y) , ((>: x) }. y)'"0 _
    modified_row =: 3 : 'y , (i.#y) delete y'
    
    modified_row_safe =: 3 : '+./"1 row_safe"1 modified_row"1 y'
    result2 =: +/ modified_row_safe data
    
  • @Rin@lemm.ee
    link
    fedilink
    39 days ago

    TypeScript

    Solution
    import { AdventOfCodeSolutionFunction } from "./solutions";
    
    
    /**
     * this function evaluates the 
     * @param levels a list to check
     * @returns -1 if there is no errors, or the index of where there's an unsafe event
     */
    export function EvaluateLineSafe(levels: Array<number>) {
        // this loop is the checking every number in the line
        let isIncreasing: boolean | null = null;
        for (let levelIndex = 1; levelIndex < levels.length; levelIndex++) {
            const prevLevel = levels[levelIndex - 1]; // previous
            const level = levels[levelIndex]; // current
            const diff = level - prevLevel; // difference
            const absDiff = Math.abs(diff); // absolute difference
    
            // check if increasing too much or not at all
            if (absDiff == 0 || absDiff > 3)
                return levelIndex; // go to the next report
    
            // set increasing if needed
            if (isIncreasing === null) {
                isIncreasing = diff > 0;
                continue; // compare the next numbers
            }
    
            //  check if increasing then decreasing 
            if (!(isIncreasing && diff > 0 || !isIncreasing && diff < 0))
                return levelIndex; // go to the next report
        }
    
        return -1;
    }
    
    
    export const solution_2: AdventOfCodeSolutionFunction = (input) => {
        const reports = input.split("\n");
    
        let safe = 0;
        let safe_damp = 0;
    
        // this loop is for every line
        main: for (let i = 0; i < reports.length; i++) {
            const report = reports[i].trim();
            if (!report)
                continue; // report is empty
    
            const levels = report.split(" ").map((v) => Number(v));
    
            const evaluation = EvaluateLineSafe(levels);
            if(evaluation == -1) {
                safe++;
                continue;
            }
            
            // search around where it failed
            for (let offset = evaluation - 2; offset <= evaluation + 2; offset++) {
                // delete an evaluation in accordance to the offset
                let newLevels = [...levels];
                newLevels.splice(offset, 1);
                const newEval = EvaluateLineSafe(newLevels);
                if(newEval == -1) {
                    safe_damp++;
                    continue main;
                }
            }
        }
    
        return `Part 1: ${safe} Part 2: ${safe + safe_damp}`;
    }
    

    God, I really wish my solutions weren’t so convoluted. Also, this is an O(N^3) solution…

        • @hades@lemm.ee
          link
          fedilink
          28 days ago

          It’s not as simple as that. You can have 20 nested for loops with complexity of O(1) if all of them only ever finish one iteration.

          Or you can have one for loop that iterates 2^N times.

          • @Rin@lemm.ee
            link
            fedilink
            18 days ago

            What do you think my complexity is?

            I think it could be maybe O(n^2) because the other for loop which tries elements around the first error will only execute a constant of 5 times in the worst case? I’m unsure.

            • @hades@lemm.ee
              link
              fedilink
              38 days ago

              It’s O(n).

              If you look at each of the levels of all reports, you will access it a constant number of times: at most twice in each call to EvaluateLineSafe, and you will call EvaluateLineSafe at most six times for each report.

            • @Gobbel2000@programming.dev
              link
              fedilink
              28 days ago

              It really depends on what your parameter n is. If the only relevant size is the number of records (let’s say that is n), then this solution takes time in O(n), because it loops over records only once at a time. This ignores the length of records by considering it constant.

              If we also consider the maximum length of records (let’s call it m), then your solution, and most others I’ve seen in this thread, has a time complexity in O(n * m^2) for part 2.

  • @wer2@lemm.ee
    link
    fedilink
    29 days ago

    Lisp

    Part 1
    (defun p1-process-line (line)
      (mapcar #'parse-integer (str:words line)))
    
    (defun line-direction-p (line)
      "make sure the line always goes in the same direction"
      (loop for x in line
            for y in (cdr line)
            count (> x y) into dec
            count (< x y) into inc
            when (and (> dec 0 ) (> inc 0)) return nil
            when (= x y) return nil
            finally (return t)))
    
    (defun line-in-range-p (line)
      "makes sure the delta is within 3"
      (loop for x in line
            for y in (cdr line)
            for delta = (abs (- x y))
            when (or (> delta 3) )
              return nil 
            finally (return t)))
    
    (defun test-line-p (line)
      (and (line-in-range-p line) (line-direction-p line)))
    
    (defun run-p1 (file) 
      (let ((data (read-file file #'p1-process-line)))
        (apply #'+ (mapcar (lambda (line) (if (test-line-p line) 1 0)) data))))
    
    
    Part 2
    (defun test-line-p2 (line)
      (or (test-line-p (cdr line))
          (test-line-p (cdr (reverse line)))
      (loop for back on line
            collect (car back) into front
            when (test-line-p (concatenate 'list front (cddr back)))
              return t
            finally (return nil)
      )))
    
    (defun run-p2 (file) 
      (let ((data (read-file file #'p1-process-line)))
        (loop for line in data
              count (test-line-p2 line))))