async function run() {
  const audioBuffer = await loadAndDecodeAudio("sample.mp3");

  // For simplicity, only using the first channel of data
  const channelData = audioBuffer.getChannelData(0);

  // This tracks the maximum average seen across all chunks
  let max = 0;

  // How many milliseconds a chunk represents
  const msPerChunk = 100;

  // How many data points will be included in each chunk
  const chunkSize = Math.round((audioBuffer.sampleRate * msPerChunk) / 1000);

  // To get the average we need to sum up all values in the chunk
  let chunkTotalValue = 0;

  // As we compute chunk averages store them in this array
  let chunkAverages = [];

  // This primarily helps cover the final case where a chunk has fewer values
  // than the chunk size
  let currentChunkSize = 0;

  for (let i = 0; i < audioBuffer.length; i++) {
    // Channel data will be between -1 and 1
    // Absolute value ensures negatives don't just cancel out positives
    const value = Math.abs(channelData[i]);

    currentChunkSize++;

    chunkTotalValue += value;

    if (i > 0 && (i % chunkSize === 0 || i === audioBuffer.length - 1)) {
      const chunkAverage = chunkTotalValue / currentChunkSize;
      if (chunkAverage > max) {
        max = value;
      }
      chunkAverages.push(chunkAverage);
      chunkTotalValue = 0;
      currentChunkSize = 0;
    }
  }

  // Use the max average we found to normalize the averages to be between 0 and 1
  const normalizedChunkValues = chunkAverages.map((avg) => {
    return avg / max;
  });

  // Create a canvas and add to the document to draw on
  const canvas = document.createElement("canvas");
  canvas.width = 720;
  canvas.height = 1280;

  document.body.appendChild(canvas);

  const ctx = canvas.getContext("2d");

  render({
    canvas,
    ctx,
    normalizedChunkValues,
    startTime: new Date().getTime(),
    msPerChunk,
  });
}

function render({ canvas, ctx, normalizedChunkValues, startTime, msPerChunk }) {
  // The elapsedTime allows us to know how far into the audio we are
  const elapsedTime = new Date().getTime() - startTime;

  // Clear the entire canvas to remove any drawings from previous frame
  ctx.fillStyle = "#000000";
  ctx.fillRect(0, 0, canvas.width, canvas.height);
  ctx.fillStyle = "#FFFFFF";

  const barWidth = 4;
  const barSpacing = 4;
  const maxBarHeight = 200;

  for (let i = 0; i < normalizedChunkValues.length; i++) {
    // normalizedChunkValues will be a float 0-1 - a percentage of max amplitude
    const value = normalizedChunkValues[i];
    // The highest amplitude part of audio will get a bar at the max height
    const barHeight = maxBarHeight * value;

    // This moves the bars based on how much time has passed
    const xOffset = (elapsedTime / msPerChunk) * (barWidth + barSpacing);

    // Spaces out the bars
    const x = i * (barWidth + barSpacing) - xOffset;

    // Centers the bars to the middle of the canvas
    const y = (canvas.height - barHeight) / 2;

    // Draws the bar at the calculated position and size
    ctx.fillRect(x, y, barWidth, barHeight);
  }

  // Calls this function again at the start of the next frame
  // Typically this is 60fps, but will depend on the display rate of your monitor
  requestAnimationFrame(render.bind(this, ...arguments));
}

// Helper function to fetch and decode from a URL
async function loadAndDecodeAudio(audioURL) {
  const response = await fetch(audioURL);
  const arrayBuffer = await response.arrayBuffer();
  return decodeAudioData(arrayBuffer);
}

// Decodes the ArrayBuffer into an AudioBuffer
// This gives access to the raw channel data which we use to generate the waveform
// https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer
// https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData
async function decodeAudioData(arrayBuffer) {
  return new Promise((resolve, reject) => {
    const audioContext = new (window.AudioContext ||
      window.webkitAudioContext)();
    audioContext.decodeAudioData(arrayBuffer, resolve, reject);
  });
}

run();

import fs from "fs";
import { log } from "console";

const lines = fs.readFileSync("./day3.txt", { encoding: "utf-8" }).split("\n");

function isDigit(c) {
  return /[\d]/.test(c);
}

function part1() {
  let sum = 0;

  for (const [rowIndex, line] of lines.entries()) {
    let partNumber = '';
    let startColIndex = 0;

    for (const [colIndex, c] of line.split('').entries()) {

      if (isDigit(c)) {
        if (!partNumber) {
          startColIndex = colIndex;
        }

        partNumber += c;
      }

      const isEndOfPartNumber = !isDigit(c) || (colIndex === line.length - 1)
      if (isEndOfPartNumber && partNumber) {

        const startRowSearchIndex = Math.max(rowIndex - 1, 0);
        const endRowSearchIndex = Math.min(rowIndex + 1, lines.length - 1);
        const startColSearchIndex = Math.max(startColIndex - 1, 0);
        const endColSearchIndex = Math.min(colIndex, line.length - 1)

        let symbolFound = false;
        for (let i = startRowSearchIndex; i <= endRowSearchIndex; i++) {
          for (let j = startColSearchIndex; j <= endColSearchIndex; j++) {
            if (/[^\d\.]/.test(lines[i][j])) {
              symbolFound = true;
            }
          }
        }

        if (symbolFound) {
          sum += Number(partNumber);
        }

        partNumber = '';
      }
    }
  }

  log(sum)
}

function part2() {
  let sum = 0;

  const gearMap = {};

  for (const [rowIndex, line] of lines.entries()) {
    let partNumber = '';
    let startColIndex = 0;

    for (const [colIndex, c] of line.split('').entries()) {

      if (isDigit(c)) {
        if (!partNumber) {
          startColIndex = colIndex;
        }

        partNumber += c;
      }

      const isEndOfPartNumber = !isDigit(c) || (colIndex === line.length - 1)
      if (isEndOfPartNumber && partNumber) {

        const startRowSearchIndex = Math.max(rowIndex - 1, 0);
        const endRowSearchIndex = Math.min(rowIndex + 1, lines.length - 1);
        const startColSearchIndex = Math.max(startColIndex - 1, 0);
        const endColSearchIndex = Math.min(colIndex, line.length - 1)

        for (let i = startRowSearchIndex; i <= endRowSearchIndex; i++) {
          for (let j = startColSearchIndex; j <= endColSearchIndex; j++) {
            if (/\*/.test(lines[i][j])) {
              const key = `${i}-${j}`;
              if (gearMap[key]) {
                sum += gearMap[key] * Number(partNumber);
              }

              gearMap[key] = Number(partNumber);
            }
          }
        }

        partNumber = '';
      }
    }
  }

  log(sum)
}

part1();
part2();

import fs from "fs";
import { log } from "console";

const lines = fs.readFileSync("./day2.txt", { encoding: "utf-8" }).split("\n");

function part1() {
  const maxDict = {
    red: 12,
    green: 13,
    blue: 14,
  };

  let sum = 0;
  let gameId = 1;
  for (const line of lines) {
    let passes = true;

    const sets = line.replace(/Game [\d]*:\s/g, "").split(";");
    for (const set of sets) {
      const colorWithCount = set.split(",");
      for (const colorCount of colorWithCount) {
        const [count, color] = colorCount.trim().split(" ");
        if (count > maxDict[color]) {
          passes = false;
        }
      }
    }

    if (passes) {
      sum += gameId;
    }

    gameId++;
  }

  log(sum);
}

function part2() {
  let sum = 0;

  for (const line of lines) {
    const sets = line.replace(/Game [\d]*:\s/g, "").split(";");
    const gameMaxMap = {};

    for (const set of sets) {

      const colorWithCount = set.split(",");
      for (const colorCount of colorWithCount) {
        const [count, color] = colorCount.trim().split(" ");

        const countAsNum = Number(count);

        const currentMax = gameMaxMap[color] || 0;
        if (countAsNum > currentMax) {
          gameMaxMap[color] = countAsNum;
        }
      }
    }

    const red = Number(gameMaxMap["red"]) || 0;
    const green = Number(gameMaxMap["green"]) || 0;
    const blue = Number(gameMaxMap["blue"]) || 0;
    const power = red * green * blue;

    sum += power;
  }

  log(sum);
}

part1();
part2();

import fs from "fs";
import { log } from "console";

const lines = fs.readFileSync("./day1.txt", {encoding: "utf-8"}).split("\n");

function isDigit(char) {
  return /^\d$/.test(char);
}

function part1() {  
  let sum = 0;

  for (const line of lines) {
    let firstNum, lastNum;
    for (const c of line) {
      if (isDigit(c)) {
        if (!firstNum) {
          firstNum = c;
        }
        lastNum = c;
      }
    }

    const twoDigit = `${firstNum}${lastNum}`;
    sum += Number(twoDigit);
  }

  log(sum);
}

function part2() {
  let sum = 0;

  for(const line of lines) {
    let digits = [];

    for (let i = 0; i < line.length; i++) {
      const c = line[i];

      if (isDigit(c)) {
        digits.push(c);
      }

      const textDigits = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'];
      const lineSubstring = line.substring(i);
      for (let d = 0; d < textDigits.length; d++) {
        const textDigit = textDigits[d];
        if (lineSubstring.startsWith(textDigit)) {
          digits.push(d+1);
        }
      }
    }

    const lastIndex = digits.length - 1;
    const twoDigits = `${digits[0]}${digits[lastIndex]}`;

    sum += Number(twoDigits);
  }

  log(sum);
}

part1();
part2();

const sampleRate = 8000;
const durationSeconds = 10;
const numChannels = 1;
const bytesPerSample = 2 * numChannels;
const bytesPerSecond = sampleRate * bytesPerSample;
const dataLength = bytesPerSecond * durationSeconds;
const headerLength = 44;
const fileLength = dataLength + headerLength;
const bufferData = new Uint8Array(fileLength);
const dataView = new DataView(bufferData.buffer);
const writer = createWriter(dataView);

// HEADER
writer.string("RIFF");
// File Size
writer.uint32(fileLength);
writer.string("WAVE");

writer.string("fmt ");
// Chunk Size
writer.uint32(16);
// Format Tag
writer.uint16(1);
// Number Channels
writer.uint16(numChannels);
// Sample Rate
writer.uint32(sampleRate);
// Bytes Per Second
writer.uint32(bytesPerSecond);
// Bytes Per Sample
writer.uint16(bytesPerSample);
// Bits Per Sample
writer.uint16(bytesPerSample * 8);
writer.string("data");

writer.uint32(dataLength);

for (let i = 0; i < dataLength / 2; i++) {
  const t = i / sampleRate;
  const frequency = 256;
  const volume = 0.6;
  const val = Math.sin(2 * Math.PI * 256 * t) * volume;
  writer.pcm16s(val);
}

const blob = new Blob([dataView.buffer], { type: 'application/octet-stream' });

audioPlayer.src = URL.createObjectURL(blob);

function createWriter(dataView) {
  let pos = 0;

  return {
    string(val) {
      for (let i = 0; i < val.length; i++) {
        dataView.setUint8(pos++, val.charCodeAt(i));
      }
    },
    uint16(val) {
      dataView.setUint16(pos, val, true);
      pos += 2;
    },
    uint32(val) {
      dataView.setUint32(pos, val, true);
      pos += 4;
    },
    pcm16s: function(value) {
      value = Math.round(value * 32768);
      value = Math.max(-32768, Math.min(value, 32767));
      dataView.setInt16(pos, value, true);
      pos += 2;
    },
  }
}