Wise Fool.
Visioneer.
data = parse(input)
folds = getFolds(input)
matrix = matrixer(data)
folded = doFold(matrix, folds)
oneFoldOfData = dots(fold(matrix, folds[0]))
parse = (text) => text.split("\n").map(k => k.split(",").map(Number)).filter(x => typeof x[1] === "number")
// takes a matrix
// returns count of "#" in matrix
dots = (paper) => paper.flat().filter((x) => x === "#").length
// takes text input
// returns object list of folding instructions
getFolds = (input) =>
input
.split("\n")
.filter(k => k.startsWith("fold along"))
.map(
k => (
([along, crease]) => ({along, crease: +crease})
)
(
k
.split(" ")[2] // only pick last entry
.split("=")
)
)
// takes list of plain data of [x, y] positions
// returns a two-dimensional matrix with "#" in the proper cells
matrixer = (data) => {
const max = (data, i) => d3.max(data, x => x[i])
const matrix = Array.from({length: max(data, 1) + 1})
.map(() => new Array(max(data, 0) + 1).fill(" "));
data.forEach(d => matrix[d[1]][d[0]] = "#");
return matrix;
}
// folding UP and LEFT are similar; LEFT only needs a double transpose
fold = (paper, {along, crease}) => {
const identity = (x) => x;
const transpose = ({"y": identity, "x": d3.transpose})[along];
return transpose(folder(transpose(paper), crease));
}
// takes a matrix and list of folds
// returns the resulting matrix with all folds applied
doFold = (matrix, folds) => {
folds.forEach(f => matrix = fold(matrix, f));
return matrix;
}
// takes the source matrix and crease position
// returns the lower part of the matrix merged with the upper part
folder = (matrix, crease) => matrix
.reverse()
.slice(crease + 1, matrix.length)
.reverse()
.map((row, r) => merge(row, matrix[r]))
// takes two rows
// returns the merger of the two rows with "#" when either has a "#"
merge = (l1, l2) => l1.map((e, i) => e === "#" || l2[i] === "#" ? "#" : ".")
// takes a list of plain data (numbers)
// returns the data as a list of objects
objectify = (data) => data.map((y, r) => y.map((x, c) => ({r, c, x}))).flat()
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
