2021/Notebooks/day08.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = open('../inputs/input-day8').read().splitlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = [l.split(' | ')[1].split(' ') for l in data]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## Task 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "lengths = [len(l) for line in output for l in line]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "255"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([lengths.count(i) for i in [2,4,3,7]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## Task 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [l.split(' | ')[0].split(' ') for l in data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "letter_mapping = {\"abcefg\":\"0\", \n",
    "                  \"cf\":\"1\",\n",
    "                  \"acdeg\":\"2\",\n",
    "                  \"acdfg\":\"3\",\n",
    "                  \"bcdf\":\"4\",\n",
    "                  \"abdfg\":\"5\",\n",
    "                  \"abdefg\":\"6\",\n",
    "                  \"acf\":\"7\",\n",
    "                  \"abcdefg\":\"8\",\n",
    "                  \"abcdfg\":\"9\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logic \n",
    "\n",
    "1. Letter \"a\" is the difference between the 3-letter and 2-letter number (digits 7,1).\n",
    "2. Letters \"d\",\"g\" are the most common in 5-letter digits, minus the \"a\" letter. \n",
    "3. \"d\" is the intersection of \"d,g\" with the difference between the 4-letter and 2-letter digits. We also get \"g\" then. \n",
    "4. \"b\" is the difference between 4-letter, 2-letter and removing \"d\". \n",
    "5. \"e\" is the letter that appears once in the list of 5-letter digits, removing \"b\".\n",
    "6. We are left with \"c,f\". Examining the 6-letter digits and removing all the rest, \"c\" should appear twice while \"f\" appears 3 times. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_size(arr, length):\n",
    "    return [l for l in arr if len(l) == length]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(line):\n",
    "    mapping = {k:None for k in \"abcdefg\"}\n",
    "    \n",
    "    two = set(find_size(line, 2)[0])\n",
    "    three = set(find_size(line, 3)[0])\n",
    "    four = set(find_size(line, 4)[0])\n",
    "    five = find_size(line, 5)\n",
    "    six = find_size(line, 6)\n",
    "    \n",
    "    (letter_a, ) = three - two\n",
    "    mapping[letter_a] = 'a'\n",
    "\n",
    "    C = Counter(\"\".join([l.replace(letter_a,\"\") for l in five])).most_common()\n",
    "    d_g = set([l[0] for l in C[:2]])\n",
    "    \n",
    "    (letter_d,) = d_g & (four - two)\n",
    "    mapping[letter_d] = 'd'\n",
    "\n",
    "    (letter_b,) = (four - two) - set(letter_d)\n",
    "    mapping[letter_b] = 'b'\n",
    "    \n",
    "    (letter_g,) = d_g - set(letter_d)\n",
    "    mapping[letter_g] = 'g'\n",
    "    \n",
    "    (letter_e,) = set([v for v,k in C if k == 1]) - set(letter_b)\n",
    "    mapping[letter_e] = 'e'\n",
    "\n",
    "    C = Counter(\"\".join([l.replace(letter_a,\"\") for l in six]))\n",
    "    \n",
    "    c_f = list(set(\"abcdefg\") - {letter_a, letter_b, letter_d, letter_e, letter_g})\n",
    "    \n",
    "    if C[c_f[0]] == 2:\n",
    "        letter_c = c_f[0]\n",
    "        letter_f = c_f[1]\n",
    "    else:\n",
    "        letter_c = c_f[1]\n",
    "        letter_f = c_f[0]\n",
    "\n",
    "    mapping[letter_c] = 'c'\n",
    "    mapping[letter_f] = 'f'\n",
    "    \n",
    "    return mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pred(l, mapping):\n",
    "    return int(\"\".join([letter_mapping[\"\".join(sorted([mapping[seg] for seg in n]))] for n in l]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "982158"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([pred(output[i], solve(inputs[i])) for i in range(len(data))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}