Jurassic Jigsaw

X = the product of the four ID numbers of the four identified corner tiles

X = the number of # characters that are not part of a sea monster pattern

Tile 1234:
..##.#..#.
##..#.....
#...##..#.
####.#...#
##.##.###.
##...#.###
.#.#.#..##
..#....#..
###...#.#.
..###..###

...more tiles

Tile 1234:

    Side 1
  ..##.#..#.
  ##..#.....
S #...##..#. S
i ####.#...# i
d ##.##.###. d
e ##...#.### e
  .#.#.#..##
4 ..#....#.. 2
  ###...#.#.
  ..###..###
    Side 3

Due to the rotation and flipping caveat...

Side 1's match could be:
..##.#..#. or .#..#.##..

Side 2's match could be:
...#.##..# or #..##.#...

Side 3's match could be:
..###..### or ###..###..

Side 4's match could be:
.#####..#. or .#..#####.

Compare the current side's string - both directions - with each of the four sides of each of the other input tiles
  If we find a match
    Record the tile name and side
    Break
  Else - there is no match
    Record the lack of match

If a tile has 0 unmatched sides, it is an inner piece
If a tile has 1 unmatched side, it is an edge piece
If a tile has 2 unmatched sides, it is a corner piece

Split the input at each pair of new line characters to create an array of tile strings

Split each tile string at the new line character to change the string into an array of strings

Change each array of strings into an array with two elements:
  1. A string that stores the tile's 4-digit ID
  2. An array that stores four strings: each string representing the ordered set of . or # characters for a tile's four sides

Change each two-item array into an array with two elements:
  1. A string that stores the tile's 4-digit ID
  2. An array that stores the existence of - or lack thereof - a matching side from another tile...for each side of each tile

Change the array to only contain a subset of its items
  Where the second element - the array of four values - has, after filtering it for non-existent matches, only two items

Return the product of each of the remaining four values' number-coerced ID

Flip vertically:
Reverse the array

Flip horizontally:
Split each string into an array
  Reverse the array
    Concatenate each element into a string

Rotate counter-clockwise:
For each string in the array
  Return a new string that is the concatenation of each character at the location in each string matching the index of the current string

Rotate clockwise:
For each string in the array
  Return a new string that is the concatenation of each character at the location in each string - of a reversed array - matching the index of the current string

Store an ordered list of each parsed tile
Store an ordered list of each pairing of tile ID and it's matching sides as calculated from Part 1
Store the size of the image by calculating the square root of the length of the list of tiles
Create two arrays of matching dimensions:
  1. To eventually hold each properly oriented tile array
  2. To eventually hold each tile id in its proper slot

Pick any of the four corner tiles to place in the top-left slot of the both grid arrays
  While it's top and left sides are not both marked as 'No match'
    Rotate it clockwise
    Shift the side instructions array such that the last item is moved to the front

For each row in the grid
  For each column in the row
    If in the top row:
      If proceeding to the right in the same row:
        Look-up the id of the tile to the left
        Store its matching tile from the list of tiles
        While its top side is not marked as 'No match'
          Rotate the tile clockwise
          Shift the side instructions array such that the last item is moved to the front
        If the characters along the right edge of the tile to the left don't match up with the characters along the left edge of the current tile
          Flip the current tile vertically
        Add the current tile and its id to the respective grid arrays
    If in the left-most column and not in the top row:
      Look-up the id of the tile above
      Store its matching tile from the list of tiles
      While its left and bottom sides are not marked as 'No match'
        Rotate the tile clockwise
        Shift the side instructions array such that the last item is moved to the front
      If the characters along the bottom edge of the tile above don't match up with the characters along the top edge of the current tile
        Flip the current tile horizontally
      Add the current tile and its id to the respective grid arrays

Setup algorithm:
Create an array to store the parsed tile strings
Complete Part 1 again to attain an array mapping each tile's side to between two and four other tiles' sides
Determine the full image's width/height by calculating the square root of either array
Create two more arrays:
  1. To store correctly placed and oriented tile strings in a multi-dimensional array
  2. To store the IDs of each correctly placed tile in a multi-dimensional array
Pick one of the four corner pieces - it doesn't matter which -  from the array mapping tile sides
Shift the elements in its side mapping array until the elements marking 'No match' are in locations 1 and 4 - the slots representing its top and left sides
Add an element to both of the new arrays:
  1. The tile string to the first array in the first nested array
  2. The ID to the first string in the first nested array
Create two legends:
  1. When attempting to align the next right-adjacent tile's known matching side with the recently placed tile, refer to an array mapping the side to the number of necessary clockwise moves to perform
  1. When attempting to align the next bottom-adjacent tile's known matching side with the recently placed tile, refer to an array mapping the side to the number of necessary clockwise moves to perform

Image-building algorithm:
Do as many times as the image is tall
  Do as many times as the image is wide
    As long as the current cell is not in the left-most location:
      Look-up the id of the tile in the cell to the left
      Look-up that tile's newly-shifted right-matching side
      Look-up the corresponding tile string
      Rotate the tile string clockwise - and shift its matching sides array - according to the legend until its identified matching side is in location 4 - representing left - of it's matching sides array
      If the strings of this tile's left side and the left adjacent tile's right side are reversed:
        Flip the tile's string vertically
        Swap the matching side array elements at locations 1 and 3 - top and bottom
      Add an element to both multi-dimensional arrays:
        1. The tile string of this tile
        2. The ID of this tile
    As long as the current cell is in the left-most location, and not in the top row:
      Look-up the id of the tile in the cell to above
      Look-up that tile's newly-shifted bottom-matching side
      Look-up the corresponding tile string
      Rotate the tile string clockwise - and shift its matching sides array - according to the legend until its identified matching side is in location 1 - representing top - of it's matching sides array
      If the strings of this tile's top side and the top adjacent tile's bottom side are reversed:
        Flip the tile's string horizontally
        Swap the matching side array elements at locations 2 and 4 - right and left
      Add an element to both multi-dimensional arrays:
        1. The tile string of this tile
        2. The ID of this tile

image.map(row => row.map(tile => {
        return tile.slice(1, 9).map(line => line.slice(1,9))
      })).map(row => row.reduce((accumulator, current) => {
        current.forEach((line, index) => {
          accumulator[index] += line
        })
        return accumulator
      }, Array(8).fill(null).map(el => '')).flat(1)).flat(1)

                  # 
#    ##    ##    ###
 #  #  #  #  #  #   

/.*(?<head>.{18}#.).*\n.*(?<body>#.{4}##.{4}##.{4}###).*\n.*(?<feet>.#.{2}#.{2}#.{2}#.{2}#.{2}#.{3}).*/g

Searched this:
.#.#...#.###...#.##.##..
#.#.##.###.#.##.##.#####
..##.###.####..#.####.##

Matched this:
                    #   
  #    ##    ##    ###  
   #  #  #  #  #  #     

Calculate the indexed location of the hash in the second line of the pattern, since it represents the left-most character in the pattern - and is therefore a reliable left edge
Use that number to create reference points for the first and third lines of the pattern from which to start
Additionally, store all three indexed first locations of the strings within which all three lines of the pattern reside - to know how far from which to indent
Furthermore, store the width of each line - since it now includes a new line character

Replace the joined string representing the image using a series of substring concatenations which craft a new string by joining each fragment of the most recent string with Os replacing each of the 18 characters in the matched sea monster pattern