AoC 2017 - 21B

let its = 0
function solve(s, runs) {
    let a = s.split('\n')
    let rules = {}
    for (let rule of a) {
        first = rule.substring(0, rule.indexOf('=') - 1)
        second = rule.substring(rule.indexOf('>') + 2).trim()
        rules[first] = second
    }
    let pix_data = [[['.#.'],['..#'],['###']]]
    //let pix_data = [[['#.'],['..']],[['.#'],['..']],[['..'],['#.']],[['..'],['.#']]]
    let iterations = 0
    let size_index = 3
    let get_new_data = (data) => {
        let m = data
        for (let rot=0; rot<4; rot++) {
            for (let fl=0; fl<2; fl++) {
                let pix_rule = m.join('/')
                if (rules[pix_rule] != undefined) {
                    return rules[pix_rule].split('/')
                }
                m = flip(m)
            }
            m = rotate(m)
        }
    }
    let condense = (data, size) => {
        let len = data.length
        let condensed = []
        for (let i=0; i<size; i++) {
            condensed.push('')
        }
        if (len == size) { return data }
        switch(size%2==0) {
            case true:
                let first_half = data.splice(0,len/2)
                let second_half = data.splice(0,len/2)
                for (let d in first_half) {
                    condensed[d%(size/2)] += first_half[d]
                }
                for (let d in second_half) {
                    condensed[(size/2) + d%(size/2)] += second_half[d]
                }
                return condensed
                break
            case false:
                let first_third = data.splice(0,len/3)
                let second_third = data.splice(0,len/3)
                let third_third = data.splice(0,len/3)
                for (let d in first_third) {
                    condensed[d%(size/3)] += first_third[d]
                }
                for (let d in second_third) {
                    condensed[(size/3) + d%(size/3)] += second_third[d]
                }
                for (let d in third_third) {
                    condensed[2*(size/3) + d%(size/3)] += third_third[d]
                }
                return condensed
                break
        }
    }
    let groupify = (c) => {
        let m = []
        let l = c[0].length
        switch(l%2==0) {
            case true:
                for (let row=0; row<l; row+=2) {
                    for (let col=0; col<l; col+=2) {
                        let top = (c[row][col] + c[row][col+1])
                        let bot = (c[row+1][col] + c[row+1][col+1])
                        m.push([[top],[bot]])
                    }
                }
                return m
                break
            case false:
                for (let row=0; row<l; row+=3) {
                    for (let col=0; col<l; col+=3) {
                        let top = (c[row][col] + c[row][col+1] + c[row][col+2])
                        let mid = (c[row+1][col] + c[row+1][col+1] + c[row+1][col+2])
                        let bot = (c[row+2][col] + c[row+2][col+1] + c[row+2][col+2])
                        m.push([[top],[mid],[bot]])
                    }
                }
                return m
                break
        }
    }
    let hash_count = 0
    while (iterations < runs) {
        iterations++
        its = iterations
        if (size_index % 2 == 0) {
            size_index = (size_index / 2) * 3
        }
        else if (size_index % 3 == 0) {
            size_index = (size_index / 3) * 4
        }
        let group_raw = []
        if (its == 1) {
            let raw_data = get_new_data(pix_data[0])
            group_raw = group_raw.concat(raw_data)
        }
        else {
            for (let group of pix_data) {
                let size = group.length
                if (size % 2 == 0) {
                    let raw_data = get_new_data(group)
                    group_raw = group_raw.concat(raw_data)
                }
                else if (size % 3 == 0) {
                    let raw_data = get_new_data(group)
                    group_raw = group_raw.concat(raw_data)
                }
            }
        }
        //console.log('raws',group_raw)
        let combined = condense(group_raw, size_index) //group_raw is all the individual squares
        //we can convert these squares into one large square using different sizes
        //console.log(size_index)
        pix_data = groupify(combined)
        //Log for display
        console.log('\n[Iteration',its-1 + ']')
        console.log(combined.join('\n'))
        let counts = 0
        for (let row in combined) {
            let temp = combined[row].split('')
            counts += temp.filter(e=>e=='#').length
        }
        hash_count = counts
    }
    console.log('Hash Count: ',hash_count)
}

function flip(a) {
    if (a.length % 2 == 0) {
        let top = a.shift()
        a.push(top)
        return a
    }
    else {
        let top = a.shift()
        let bot = a.pop()
        a.unshift(bot)
        a.push(top)
        return a
    }
}

function rotate(mat) {
    var matrix = []
    for (let i of mat) {
        i = i[0].split('')
        matrix.push(i)
    }
    matrix = matrix.reverse()
    // swap the symmetric elements
    for (var i = 0; i < matrix.length; i++) {
      for (var j = 0; j < i; j++) {
        var temp = matrix[i][j]
        matrix[i][j] = matrix[j][i]
        matrix[j][i] = temp
      }
    }
    var remat = []
    for (let i of matrix) {
        i = i.join('')
        remat.push([i])
    }
    return remat
}

const fs = require('fs')
const path = 'day21.txt'
fs.readFile(path, 'utf8', (e, input) => {
    solve(input,5)
    //solve(input,18)
})