structure_trees/a_morse_code_tree.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "29e43a9b-4fe9-4fa4-83fc-8bc7cc733914",
   "metadata": {},
   "source": [
    "# a morse code tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85da8440-0286-4fc5-8009-a1dbbbeaf195",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.101computing.net/morse-code-using-a-binary-tree/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "18c38e4e-67f6-4814-a9ee-014af7b231dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# modified left and right pointers to dot and dash\n",
    "class Node:\n",
    "    def __init__(self, value, dot=None, dash=None):\n",
    "        self.value = value\n",
    "        self.dot = dot\n",
    "        self.dash = dash"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "93595ce3-cbd6-4b58-ad8d-b25d89a14b11",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMorseCode(node, character, code):\n",
    "    if node==None:\n",
    "        return False\n",
    "    elif node.value==character:\n",
    "        # return to end program\n",
    "        return True\n",
    "    # keep traversing when the pointer is not pointing to null\n",
    "    else:  \n",
    "        if getMorseCode(node.dot,character,code)==True:\n",
    "          code.insert(0,\".\")\n",
    "          return True\n",
    "        elif getMorseCode(node.dash,character,code)==True:\n",
    "          code.insert(0,\"-\")\n",
    "          return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "1da7f6e4-114b-4087-a777-65a21525a51b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# printing tree utility \n",
    "# this segment is modified from Shubham Singh(SHUBHAMSINGH10)'s contribution \n",
    "\n",
    "# spacer\n",
    "COUNT = [10]\n",
    "\n",
    "# print a flat lying tree\n",
    "# speculation： this is a recursion that prints the right leaf until there is nothing left\n",
    "def print2DUtil_flat(root, space) :\n",
    "    # Base case\n",
    "    if (root == None) :\n",
    "        return\n",
    "    # Increase distance between levels\n",
    "    space += COUNT[0]\n",
    "    # Process right leaf/branch/child first\n",
    "    print2DUtil_flat(root.dash, space)\n",
    "    print()\n",
    "    for i in range(COUNT[0], space):\n",
    "        print(end = \" \")\n",
    "    print(root.value)\n",
    "    \n",
    "    #for i in range(COUNT[0], space):\n",
    "    #    print(end = \" \")\n",
    "    #print(root.letter) \n",
    "    #print(root.value)\n",
    "    # Process left child\n",
    "    print2DUtil_flat(root.dot, space)\n",
    "\n",
    "    # Wrapper over print2DUtil()\n",
    "def print2D(root) :\n",
    "    #Pass initial space count as 0\n",
    "    print(\"here is a tree that's laying on the ground: \")\n",
    "    print2DUtil_flat(root, 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "c0e844a1-3d41-40e5-afde-9ff16de294d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's initialise our binary tree:\n",
    "tree = Node(\"START\") #The root node of our binary tree\n",
    "\n",
    "# 1st Level\n",
    "tree.dot = Node(\"E\")\n",
    "tree.dash = Node(\"T\")\n",
    "\n",
    "# 2nd Level\n",
    "tree.dot.dot = Node(\"I\")\n",
    "tree.dot.dash = Node(\"A\")\n",
    "tree.dash.dot = Node(\"N\")\n",
    "tree.dash.dash = Node(\"M\")\n",
    "\n",
    "# 3rd Level\n",
    "tree.dot.dot.dot = Node(\"S\")\n",
    "tree.dot.dot.dash = Node(\"U\")\n",
    "tree.dot.dash.dot = Node(\"R\")\n",
    "tree.dot.dash.dash = Node(\"W\")\n",
    "\n",
    "tree.dash.dot.dot = Node(\"D\")\n",
    "tree.dash.dot.dash = Node(\"K\")\n",
    "tree.dash.dash.dot = Node(\"G\")\n",
    "tree.dash.dash.dash = Node(\"O\")\n",
    "\n",
    "# 4th Level\n",
    "tree.dot.dot.dot.dot = Node(\"H\")\n",
    "tree.dot.dot.dot.dash = Node(\"V\")\n",
    "tree.dot.dot.dash.dot = Node(\"F\")\n",
    "tree.dot.dot.dash.dash = Node(\"\")\n",
    "tree.dot.dash.dot.dot = Node(\"L\")\n",
    "tree.dot.dash.dot.dash = Node(\"\")\n",
    "tree.dot.dash.dash.dot = Node(\"P\")\n",
    "tree.dot.dash.dash.dash = Node(\"J\")\n",
    "\n",
    "tree.dash.dot.dot.dot = Node(\"B\")\n",
    "tree.dash.dot.dot.dash = Node(\"X\")\n",
    "tree.dash.dot.dash.dot = Node(\"C\")\n",
    "tree.dash.dot.dash.dash = Node(\"Y\")\n",
    "tree.dash.dash.dot.dot = Node(\"Z\")\n",
    "tree.dash.dash.dot.right = Node(\"Q\")\n",
    "tree.dash.dash.dash.dot = Node(\"\")\n",
    "tree.dash.dash.dash.dash = Node(\"\")\n",
    "\n",
    "# how to insert letters without entering one by one? use what structure?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "be1252af-f941-47c1-a717-dd04f53e0c68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here is a tree that's laying on the ground: \n",
      "\n",
      "                                        \n",
      "\n",
      "                              O\n",
      "\n",
      "                                        \n",
      "\n",
      "                    M\n",
      "\n",
      "                              G\n",
      "\n",
      "                                        Z\n",
      "\n",
      "          T\n",
      "\n",
      "                                        Y\n",
      "\n",
      "                              K\n",
      "\n",
      "                                        C\n",
      "\n",
      "                    N\n",
      "\n",
      "                                        X\n",
      "\n",
      "                              D\n",
      "\n",
      "                                        B\n",
      "\n",
      "START\n",
      "\n",
      "                                        J\n",
      "\n",
      "                              W\n",
      "\n",
      "                                        P\n",
      "\n",
      "                    A\n",
      "\n",
      "                                        \n",
      "\n",
      "                              R\n",
      "\n",
      "                                        L\n",
      "\n",
      "          E\n",
      "\n",
      "                                        \n",
      "\n",
      "                              U\n",
      "\n",
      "                                        F\n",
      "\n",
      "                    I\n",
      "\n",
      "                                        V\n",
      "\n",
      "                              S\n",
      "\n",
      "                                        H\n"
     ]
    }
   ],
   "source": [
    "# print morse code tree configuration\n",
    "print2D(tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "c9e6e242-c742-416e-b2cb-550d4e7a8ff2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a message to convert into Morse Code: (e.g. SOS) hwllo\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".... .-- .-.. .-.. --- \n"
     ]
    }
   ],
   "source": [
    "#Message Input\n",
    "message = input(\"Enter a message to convert into Morse Code: (e.g. SOS)\").upper()\n",
    "morseCode = \"\"\n",
    "\n",
    "#Convert the message, one character at a time!\n",
    "for character in message:\n",
    "    dotsdashes = []\n",
    "    getMorseCode(tree,character,dotsdashes)\n",
    "    code = \"\".join(dotsdashes)\n",
    "    morseCode = morseCode + code + \" \"\n",
    "print(morseCode)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93252875-0f4f-40f8-af62-b027f916eb60",
   "metadata": {},
   "source": [
    "# todo \n",
    "modify the tree print out to show the dots and dashes \n",
    "take a user input in morse code, and use the binary tree to decode the message one character at a time\n",
    "translate the dot dash signals into other forms of pulsations: LED light, sound to be sent out via radio signal, ?FSK (written on the code memo)\n",
    "would be nice to emphasize the traversal aspect, can it be displayed / heard - traversing to the dot! traversing to the dash! make it procedural -> maybe console can be helpful "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddeba74b-f6bc-4e06-ab2b-3b176a485bc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# reference project\n",
    "# https://microbit-micropython.readthedocs.io/en/latest/tutorials/radio.html\n",
    "# https://new.pythonforengineers.com/blog/audio-and-digital-signal-processingdsp-in-python/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}