copy pasting the rules from last year’s thread:

Rules: no spoilers.

The other rules are made up aswe go along.

Share code by link to a forge, home page, pastebin (Eric Wastl has one here) or code section in a comment.

  • @ArchiteuthisOP
    link
    English
    2
    edit-2
    10 hours ago
    discussion

    Same, except in 4-1 I used a recursive function to traverse each direction according to the offset decided by the selected direction (like SW is row++,col–) , due to functional programming induced brain damage.

    Would have been pretty useful too if 4-2 turned out to be about finding longer patterns, instead of smaller and in half the directions.

    4-1

    Inlined some stuff to fit everything in one function:

    let rec isXmas (row:int) (col:int) (dir:int) (depth:int) (arr: char array2d) : bool =
        let value = arr.[row,col]
        if depth = 3
        then value = 'S'
        else if  [|'X';'M';'A';'S'|].[depth] = value
        then
            let (nextRow, nextCol) =
                match dir with
                | 1 -> row + 1, col - 1
                | 2 -> row + 1, col
                | 3 -> row + 1, col + 1
                | 4 -> row, col - 1
                | 6 -> row, col + 1
                | 7 -> row - 1, col - 1
                | 8 -> row - 1, col
                | 9 -> row - 1, col + 1
                | _ -> failwith $"{dir} isn't a numpad direction." 
    
            let rowCount = arr |> Array2D.length1
            let colCount = arr |> Array2D.length2
           
            if nextRow >= 0 && nextRow < rowCount && nextCol >= 0 && nextCol < colCount
            then isXmas nextRow nextCol dir (depth+1) arr
            else false
        else false
    

    Then you run this for every appropriately pruned ‘X’ times every direction and count the trues.