Day 8: Space Image Format

width = 25
height = 6
layer_len = width * height
layers = [(input_string[i:i+layer_len]) for i in range(0, len(input_string), layer_len)] 
most_0s = 0
most_0s_string = ''
least_0s = 150
least_0s_string = ''
for layer in layers:
    zero_count = 0
    for i in layer: 
        if i == '0': 
            zero_count = zero_count + 1
    if zero_count > most_0s:
        most_0s = zero_count
        most_0s_string = layer
    if zero_count < least_0s:
        least_0s = zero_count
        least_0s_string = layer
        
ones_count = 0
twos_count = 0
for i in least_0s_string:
    if i == '1': 
        ones_count = ones_count + 1
    if i == '2': 
        twos_count = twos_count + 1
        
        
print(most_0s)
print(most_0s_string)
print(least_0s)
print(least_0s_string)
print(ones_count)
print(twos_count)

def divide_chunks(l, n): 
    # looping till length l 
    for i in range(0, len(l), n):  
        yield l[i:i + n] 

final_result = list(['transparent'] * (width * height))
for layer in layers:
    for i in range(len(layer)):
        if final_result[i] == 'transparent':
            #print(layer[i])
            if layer[i] is '0':
                #print('This is black')
                final_result[i] = '█'
            elif layer[i] is '1':
                #print('This is white')
                final_result[i] = ' '
print(final_result)


output_split = list(divide_chunks(final_result, width)) 
print (output_split) 
for row in output_split:
    row_merged = ""
    for char in row:
        row_merged = row_merged + char
    print(row_merged)

const checkSum = (pixels, width, height) => {
  let zeroCount = 0;
  let oneCount = 0;
  let twoCount = 0;
  let fewestZeros = Number.MAX_VALUE;
  let checkSum = 0;

  const layerCount = pixels.length / (width * height);
  for (let layer = 0; layer < layerCount; layer++) {
    for (let row = 0; row < height; row++) {
      for (let column = 0; column < width; column++) {
        const pixel = pixels[layer * height * width + row * width + column];
        if (pixel === "0") {
          zeroCount++;
        } else if (pixel === "1") {
          oneCount++;
        } else if (pixel === "2") {
          twoCount++;
        }
      }
    }
    if (zeroCount < fewestZeros) {
      fewestZeros = zeroCount;
      checkSum = oneCount * twoCount;
    }

    zeroCount = 0;
    oneCount = 0;
    twoCount = 0;
  }

  return checkSum;
};

const drawImage = (pixels, width, height) => {
  const layerCount = pixels.length / (width * height);
  for (let row = 0; row < height; row++) {
    let imageRow = "";
    for (let column = 0; column < width; column++) {
      for (let layer = 0; layer < layerCount; layer++) {
        const pixel = pixels[layer * height * width + row * width + column];
        if (pixel === "2") {
          continue;
        } else {
          content = pixel === "1" ? "#" : " ";
          imageRow += content;
          break;
        }
      }
    }
    console.log(imageRow);
  }
};

const width = 25;
const height = 6;
const pixels = input.split("");

console.log(`checkSum = ${checkSum(pixels, width, height)}`);

drawImage(pixels, width, height);

Part 1: Keep a count of all 0s,1s, and 2s per layer and keep a running minimum where when the number of 0s is less than the min, update the min and remember the number of 1s * the number of 2s in that layer.

Part 2: We're going down layer by layer, so for each pixel in a layer, if that pixel (row/col) is not transparent and our "final image" currently doesn't have anything for that pixel position, stick it in the final image.

Yes we have to do some interpretation, but the final result is definitely good enough to spell something out.

Once done, print the product of the min layer and the final image (with black pixels emphasized).

#include <bits/stdc++.h>
using namespace std;
int res[6][25];
int main() {
	string s;
	cin >> s;
	int sz = s.size()/(25*6);
	int ma = 99999999,res1 = 0;
	memset(res,-1,sizeof(res));
	for(int k=0;k<sz;k++) {
		int p[3] = {0,0,0};
		for(int i=0;i<6;i++) {
			for(int j=0;j<25;j++) {
				int id = s[j+25*i+150*k];
				id -= '0';
				p[id]++;
				if(res[i][j] == -1 && id != 2) {
					res[i][j] = id;
				}
			}
		}
		if(p[0] < ma) {
			ma = p[0];
			res1 = p[1]*p[2];
		}
	}
	cout << "Part 1: " << res1 << '\n';
	cout << "Part 2:\n";
	for(int i=0;i<6;i++) {
		for(int j=0;j<25;j++) {
			if(res[i][j]) {cout << "#";} else {
				cout << ".";
			}
		}
		cout << '\n';
	}
}

import Foundation
typealias Layer = [Pixel]

enum Pixel: Character, CustomStringConvertible {
    case black = "0"
    case white = "1"
    case transparent = "2"
    
    var description: String {
        switch self {
        case .transparent:
            return "."
        case .black:
            return " "
        case .white:
            return "*"
        }
    }
}

func getLayers(pixels: Layer, layerSize size: Int) -> [Layer] {
   return stride(from: 0, to: pixels.count, by: size).map {
       Array(pixels[$0..<($0 + size)])
   }
}

func validateImage(layers: [Layer]) -> Int {
    let countPixel = {(a: Layer, b: Pixel) -> Int in
        a.filter { $0 == b }.count
    }
    let min = layers.min { countPixel($0, .black) < countPixel($1, .black) }!
    let val = countPixel(min, .white) * countPixel(min, .transparent)
    
    return val
}

func decode(layers: [Layer]) -> Layer {
    var finalImage = layers.first!
    for layer in layers {
        for (idx, c) in layer.enumerated() {
            if finalImage[idx] == .transparent {
               finalImage[idx] = c
            }
        }
    }
    return finalImage
}

func go(input i: String, width: Int, height: Int) {
    let input: Layer = i.filter {$0.isWholeNumber}.map { Pixel(rawValue: $0)! }
    let size = width * height
    
    let layers = getLayers(pixels: Array(input), layerSize: size)
    
    let checksum = validateImage(layers: layers)
    print(checksum)
    
    let finalImage = decode(layers: layers)
    var str = ""
    for (idx, pixel) in finalImage.enumerated() {
        if idx > 0 && idx % width == 0 {
            str += "\n"
        }
        str += pixel.description
    }
    print(str)
}

guard let fileContents = try? String(contentsOfFile: "input.txt") else {
    fatalError("Cannot open input file")
}

go(input: fileContents, width: 25, height: 6)

#!/usr/bin/awk -f
{ img = img $0 }

END {
    fewest = 0
    for (i = 1; i <= length(img); ++i) {
        layers[i] = substr(img, 1, 150)
        img = substr(img, 151)
        count = gsub(/0/, "0", layers[i])
        if (count < fewest || ! fewest) {
            j = i
            fewest = count
        }
    }

    print gsub(/1/, "1", layers[j]) * gsub(/2/, "2", layers[j])
}

#!/usr/bin/awk -f
{ img = img $0 }

END {
    width = 25
    height = 6
    len = width * height
    for (i = 1; i <= length(img); ++i) {
        layers[i] = substr(img, 1, len)
        img = substr(img, len+1)
    }

    img = ""
    for (i = 1; i <= len && k = 1; ++i) {
        for (;;) {
            j = substr(layers[k], i, 1)
            if (j == 2)
                k += 1
            else
                break
        }

        img = img j
    }

    for (i = 1; i <= length(img); i += width)
        print substr(img, i, width)
}

#!/usr/bin/env crystal
require "colorize"

INPUT = ARGV.size > 0 ? ARGV[0] : "day8/input.txt"
data = File.read(INPUT).strip

WIDTH = 25
HEIGHT = 6

COLORS = {
  0 => :black,
  1 => :white,
  2 => :transparent
}

def split_layers(data, width, height)
  data
    .chars
    .in_groups_of(width * height, '-')
    .reduce([] of Array(Int32)) do |layers, layer|
    layers << layer
             .reject { |c| ! c.number? }
             .map { |c| c.to_i }
  end
end

def layer_counts(layers)
  layers.reduce(Array(Hash(Int32,Int32)).new) do |layer_counts, layer|
    layer_counts << (0..2).each_with_object({} of Int32 => Int32) { |i,h| h[i] = layer.count(i) }
  end
end

def find_layer_with_least(layer_counts, val=0)
  layer_counts.reduce(layer_counts[0]) { |best, cur|
    cur[val] < best[val] ? cur : best
  }
end

# Part 1
layers = split_layers(data, WIDTH, HEIGHT)
counts = layer_counts(layers)

least_zs = find_layer_with_least(counts, 0)
puts "Part 1: %i" % (least_zs[1] * least_zs[2])

# Part 2
def flatten(layers)
  layers.reverse.reduce(Array(Int32).new(WIDTH*HEIGHT,2)) do |output, layer|
    layer.each_with_index do |v, i|
      output[i] = v unless v == 2
    end
    output
  end
end

print "Part 2:"
flattened = flatten(layers)
flattened.each_with_index do |val, i|
  if i % WIDTH == 0
    print '\n'
  end

  color = COLORS[val]

  print " ".colorize.back(color)
end
print '\n'

My code below has a slightly cleaned up method of output, since I submitted the answer and then realized I was a fool for squinting at a grid of numbers instead of formatting it nicely.

def read_image(file_name):

    with open(file_name, 'r') as fid:
        raw_image = fid.read().strip()

    return raw_image

def layerize_image(raw_image, height, width):

    raw_image = [int(num) for num in raw_image]

    count = 0
    layered_image = []

    while count < len(raw_image):
        layer = []
        for i in range(height):
            row = []
            for j in range(width):
                row.append(raw_image[count])
                count += 1

            layer.append(row)
        layered_image.append(layer)

    return layered_image

def count_layer_instances(layer_img, target):

    layer_totals = []

    for layer in layer_img:
        count = 0
        for row in layer:
            for num in row:
                if num == target:
                    count += 1

        layer_totals.append(count)

    return layer_totals

def validate_image(input_file, height, width):

    raw_image = read_image(input_file)

    layer_img = layerize_image(raw_image, height, width)

    zeros = count_layer_instances(layer_img, 0)

    target_layer = zeros.index(min(zeros))

    ones = count_layer_instances(layer_img, 1)
    twos = count_layer_instances(layer_img, 2)

    return ones[target_layer] * twos[target_layer]

def display_image(image):

    for row in image:
        row_str = ""
        for num in row:
            if num:
                row_str += str(num)
            else:
                row_str += " "
        print(row_str)

def decode_image(input_file, height, width):

    raw_image = read_image(input_file)

    layer_img = layerize_image(raw_image, height, width)

    done_pixels = [[False for i in range(width)] for j in range(height)]
    final_img = [[0 for i in range(width)] for j in range(height)]

    for layer in layer_img:

        for idx in range(height):
            for jdx in range(width):

                if not done_pixels[idx][jdx]:
                    if layer[idx][jdx] != 2:
                        final_img[idx][jdx] = layer[idx][jdx]
                        done_pixels[idx][jdx] = True

    display_image(final_img)
    return final_img


input_file = "PuzzleInput.txt"
layer_width = 25
layer_height = 6

result = validate_image(input_file, layer_height, layer_width)

print(result)

final_img = decode_image(input_file, layer_height, layer_width)