onebigear
/
structure_trees
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

first commit, add all prev working files

Browse Source
main
onebigear 3 years ago
commit faf250a6d5
128 changed files with 7373 additions and 0 deletions
Show Stats Download Patch File Download Diff File

12
.ipynb_checkpoints/READTREES-checkpoint.md
Unescape Escape View File

@ -0,0 +1,12 @@
# ABOUT
A series of programs that builds on the tree structure, an abstract data
type used for presenting, storing and searching information
# VALUE IN MEDIA ARCHAEOLOGY
# VALUE IN CRITICAL STUDIES
# FORMAT
Textual outputs are stored as txt files, and image outputs are stored as image files. The program process is stored in Jupyter Notebooks.
# WHERE IS THIS FORKED FROM
# FORK YOUR OWN

303
.ipynb_checkpoints/a_bonary_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,303 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# a bonary tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#***********************************************************************\n",
"#** a bo-binary tree *\n",
"#** for and inspired by Wang Xiaobo (1952-1997), writer and programmer.*\n",
"#** \"我也自做了词组功能，是棵B树，我觉得自写的软件自用，感觉是最好的。\" *\n",
"#** \"I created a word feature with a binary tree strucutre, *\n",
"#** and I feel best about using a program you created yourself.\" *\n",
"#** read more in archival documentation(Chinese): *\n",
"#** https://blog.csdn.net/weixin_33697898/article/details/93356187 *\n",
"#** *\n",
"#***********************************************************************"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 思维的乐趣 \n",
"### on discourse \n",
"### quotes from 《我的精神家园》\n",
"谈到思想的乐趣，我就想到我父亲的遭遇。我父亲是一位哲学教授，在五六十年代从事思维史的研究。在老年时，他告诉我自己一生的学术经历，就如一部恐怖电影。每当他企图立论时，总要在大一统的思想体系里找到自己的位置，就如一只老母鸡要在一个大搬家的宅院里找地方孵蛋一样。结果他虽然热爱科学而且很努力，在一生中却没有得到思维的乐趣，之收获了无数的恐慌。他一生的探索，只剩下了一些断壁残垣，收到一本名为《逻辑探索》的书里，在他身后出版。\n",
"\n",
"我在沉默中过了很多年：插队、当工人、当大学生，后来又在大学里任过教。当教师的人保持沉默似不可能，但我教的是技术性的课程，在讲台上只讲技术性的话，下了课我就走人。找我看，不管干什么都可以保持沉默。当然，我还有一个终身爱好，就是写小说。但是写好了不拿去发表，同样也保持了沉默。至于沉默的理由，很是简单。那就是信不过话语圈。从我短短的人生经历看，它是一座声名狼藉的疯人院。当时我怀疑的不是说过亩产三十万斤粮、炸过精神原子弹的那个话语圈，而是一切话语圈子。\n",
"\n",
"还有一些人，因为种种原因，对于话语的世界有某种厌恶之情。我属于这最后一种。作为最后一种人，也有义务谈自己的所见所闻。\n",
"\n",
"王小波（1997).《我的精神家园》.北京：文化艺术出版社.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Create a proof of concept dictionary tree that looks for hong(3) fu(2)"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from anytree import Node, RenderTree\n",
"h = Node(\"h\")\n",
"o = Node(\"o\", parent=h)\n",
"n = Node(\"n\", parent=o)\n",
"g = Node(\"g\", parent=n)\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Node('/h')\n",
"Node('/h/o/n/g')\n",
"h\n",
"└── o\n",
" └── n\n",
" └── g\n"
]
}
],
"source": [
"#print node\n",
"print(h)\n",
"print(g)\n",
"\n",
"#print tree\n",
"for pre, fill, node in RenderTree(h):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"f\n",
"└── u\n"
]
}
],
"source": [
"f = Node(\"f\")\n",
"u = Node(\"u\", parent = f)\n",
"for pre, fill, node in RenderTree(f):\n",
"\tprint(\"%s%s\" %(pre,node.name))\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"y\n",
"└── e\n"
]
}
],
"source": [
"y = Node(\"y\")\n",
"e = Node(\"e\", parent = y)\n",
"for pre, fill, node in RenderTree(y):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"b\n",
"└── e\n",
" └── n\n"
]
}
],
"source": [
"b = Node(\"b\")\n",
"e = Node(\"e\", parent = b)\n",
"n = Node(\"n\", parent = e)\n",
"for pre, fill, node in RenderTree(b):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def printTree(root):\n",
" for pre, fill, node in RenderTree(root):\n",
" print(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"h\n",
"└── o\n",
" └── n\n",
" └── g\n",
"红\n",
"\n",
"f\n",
"└── u\n",
"拂\n",
"\n",
"y\n",
"└── e\n",
"夜\n",
"\n",
"b\n",
"└── e\n",
" └── n\n",
"奔\n",
"\n"
]
}
],
"source": [
"tree_list = [h,f,y,b]\n",
"红拂夜奔 = [\"红\",\"拂\",\"夜\",\"奔\"]\n",
"counter = 0\n",
"for tree in tree_list:\n",
" printTree(tree)\n",
" print(红拂夜奔[counter])\n",
" counter = counter + 1\n",
" print()"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# an alphabet binary search tree\n",
"import string\n",
"alphabet_s = string.ascii_lowercase\n",
"alphabet_l = list(alphabet_s)\n",
"#print(alphabet_l)\n",
"# add nodes manually, starting from m "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<video src=\"vid/wang_interview.mp4\" controls >\n",
" Your browser does not support the <code>video</code> element.\n",
" </video>"
],
"text/plain": [
"<IPython.core.display.Video object>"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import IPython.display \n",
"Video('vid/wang_interview.mp4')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# transcription of wang's interview in Chinese\n",
"# autotranslate that into English for non-Chinese readers"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"数据结构是思维的形状的一种表现方式\n",
"the structure of data may be one representation of the form of thought "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wang Xiaobo (1952-1997), writer and programmer. <br>\n",
"\"我也自做了词组功能，是棵B树，我觉得自写的软件自用，感觉是最好的。\" <br>\n",
"\"I created a word feature with a binary tree strucutre, and I feel best about using a program you created yourself.\"\n",
"read more in archival documentation(Chinese):<br>\n",
"https://blog.csdn.net/weixin_33697898/article/details/93356187"
]
}
],
"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": 4
}

79
.ipynb_checkpoints/a_conversation_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,79 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "666a35e1-435d-4555-8193-9258ff568e21",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,question):\n",
" self.yes = None\n",
" self.no = None\n",
" self.question = question\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "254b714a-2504-4cc0-9a78-21d406ddbb2f",
"metadata": {},
"outputs": [],
"source": [
"# tree traversals, here to print stuff \n",
"def inorder(treeName):\n",
" if treeName:\n",
" inorder(treeName.yes)\n",
" print(treeName.question)\n",
" inorder(treeName.no)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e8512457-7944-4604-92c7-29f90ab6c3db",
"metadata": {},
"outputs": [],
"source": [
"# interactive user input utility \n",
"def saysYes(ques):\n",
" while True:\n",
" ans = input(ques)\n",
" ans = ans[0:1].lower()\n",
" if ans == 'y': return True\n",
" else : return False"
]
},
{
"cell_type": "markdown",
"id": "8415d1d2-211a-4e82-b331-85527e8c1510",
"metadata": {},
"source": [
"reference\n",
"https://web.stonehill.edu/compsci/CS211/Assignmenta%202015/TreeAssignment.pdf"
]
}
],
"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
}

46
.ipynb_checkpoints/a_cutting_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,46 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "baf7d8e8-1cc2-4f18-b5a7-ce5bb7c45bef",
"metadata": {},
"source": [
"# a cutting tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b6057018-bdeb-429a-8e66-130419251ef9",
"metadata": {},
"outputs": [],
"source": [
"# during an evening walk after the marshall fire, i saw a local\n",
"# tree trimming company handling trees that were either entirely \n",
"# fallen off or were dangling. the trees needed to be removed as\n",
"# they may be of hazard for the pedestrians and the road. "
]
}
],
"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
}

750
.ipynb_checkpoints/a_fruit_tree_with_hanging_pictures-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,750 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "9da34557-037a-436f-bbaa-d332057cbe18",
"metadata": {},
"source": [
"# a fruit tree with a variety of fruits hanging, each enclosed in a picture frame. "
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "01acaa97-796a-4e34-9ee3-a46e71493d9d",
"metadata": {},
"outputs": [],
"source": [
"fruit_list = [\"apricot\",\"blood_orange\",\"currant\",\"durian\",\"egg_fruit\",\"fig\",\"guava\",\n",
" \"hawthorne\",\"jujube\",\"kiwi\",\"lychee\",\"mandarin\",\"nectarine\",\"olive\",\"persimmon\",\"quandong\",\"rambutan\",\"star_fruit\",\n",
" \"tangor\",\"ugli_fruit\",\"vanilla\",\"water_chestnut\",\"ximenia\",\"yuzu\",\"zhe\"]\n",
"# additionally: longan yumberry sugarcane "
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "08ab8673-9b5c-4bd0-9fac-72796e831b94",
"metadata": {},
"outputs": [],
"source": [
"# build the fruit motley tree with extra utilities than the letter tree"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "9c7187e4-0c49-4908-a169-775e6e475f94",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,wordFruit,path):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.wordFruit = wordFruit\n",
" # try using a list structure to contain the words in this node? \n",
" self.path = path"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "11dbf280-6c61-4020-bfe7-e85a723697db",
"metadata": {},
"outputs": [],
"source": [
"# printing tree utility \n",
"# the display cannot indent?\n",
"from IPython.display import Image\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",
" print2DUtil_flat(root.rightAlphabet, space)\n",
" print()\n",
" \n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" url_tree = root.path\n",
" i = Image(url= url_tree, width=30, height=30)\n",
" display(i)\n",
"\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.wordFruit)\n",
" print2DUtil_flat(root.leftAlphabet, 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",
" # import image module\n",
" # get the image\n",
" print2DUtil_flat(root, 0)\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "d0bcd376-491e-48e9-8bd9-e10d91346d7f",
"metadata": {},
"outputs": [],
"source": [
"def urljoin(wordFruit):\n",
" url = \"images/pic_tree_fruit_img/\" + wordFruit + \".png\"\n",
" return url "
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "7a12a00f-f7b0-4234-a06c-54c6f3d1daf1",
"metadata": {},
"outputs": [],
"source": [
"def insertLeaf(root,wordFruit):\n",
" #create new leaf \n",
" url = urljoin(wordFruit)\n",
" newleaf = letterLeaf(wordFruit,url)\n",
" #print(\"creating leaf with word = {} url = {}\".format(newleaf.wordFruit,newleaf.path))\n",
"\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (wordFruit < x.wordFruit):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (wordFruit < y.wordFruit):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "dc2230e9-0831-4e3c-93b8-c96d20fd0525",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"here is a tree that's laying on the ground: \n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/zhe.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" zhe\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/yuzu.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" yuzu\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/ximenia.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" ximenia\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/water_chestnut.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" water_chestnut\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/vanilla.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" vanilla\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/ugli_fruit.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" ugli_fruit\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/tangor.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" tangor\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/star_fruit.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" star_fruit\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/rambutan.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" rambutan\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/quandong.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" quandong\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/persimmon.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" persimmon\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/olive.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" olive\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/nectarine.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" nectarine\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/mandarin.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" mandarin\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/lychee.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" lychee\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/kiwi.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" kiwi\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/jujube.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" jujube\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/hawthorne.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" hawthorne\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/guava.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" guava\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/fig.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" fig\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/egg_fruit.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" egg_fruit\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/durian.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" durian\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/currant.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" currant\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/blood_orange.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" blood_orange\n",
"\n"
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/apricot.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"apricot\n"
]
}
],
"source": [
"# same deal, insert everything in the list until it's empty \n",
"import random\n",
"\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_fruit = random.choice(fruit_list)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insertLeaf(root, random_fruit)\n",
"# remove that letter from list\n",
"fruit_list.remove(random_fruit)\n",
"#print(fruit_list)\n",
"len_list = (len(fruit_list))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_fruit = random.choice(fruit_list)\n",
" insertLeaf(root,random_fruit)\n",
" fruit_list.remove(random_fruit)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations\n"
]
}
],
"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
}

33
.ipynb_checkpoints/a_genetic_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "b8bb6f10-0461-4fb9-9f36-9b64ae33405c",
"metadata": {},
"source": [
"# a genetic tree"
]
}
],
"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
}

409
.ipynb_checkpoints/a_letter_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,409 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "4708c5dc-a1e8-42e2-8702-ecea9513d54b",
"metadata": {},
"source": [
"# a binary tree of leaves of letters"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "906fc548-a2a5-411b-ad60-9e93e88bf7f5",
"metadata": {},
"outputs": [],
"source": [
"# http://syllabus.cs.manchester.ac.uk/ugt/2021/COMP26912/lab/ex5.html\n",
"# https://web.stanford.edu/class/archive/cs/cs106x/cs106x.1174/assn/twentyOneQuestions.html\n",
"# https://www.openbookproject.net/py4fun/animal/animal.html"
]
},
{
"cell_type": "code",
"execution_count": 330,
"id": "578e93f8-e04f-4b01-a482-ebc78cf2c103",
"metadata": {},
"outputs": [],
"source": [
"# each leaf stores a letter to be asked\n",
"class letterLeaf:\n",
" def __init__(self,letter):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.letter = letter\n",
" # try using a list structure to contain the words in this node? \n",
" self.words = []"
]
},
{
"cell_type": "code",
"execution_count": 331,
"id": "fa8e3d45-ea21-47e1-9a5a-256e5e7ebed1",
"metadata": {},
"outputs": [],
"source": [
"# tree traversals, here to print stuff \n",
"def inorder(treeName):\n",
" if treeName:\n",
" inorder(treeName.leftAlphabet)\n",
" print(treeName.letter)\n",
" inorder(treeName.rightAlphabet)"
]
},
{
"cell_type": "code",
"execution_count": 332,
"id": "0c75f820-46c4-46af-b5d9-b837cb055b55",
"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.rightAlphabet, space)\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
" # Process left child\n",
" print2DUtil_flat(root.leftAlphabet, 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": 333,
"id": "5f27d6d6-3019-4714-98d0-9650f1e087bb",
"metadata": {},
"outputs": [],
"source": [
"# utility to read the first letter of the input word \n",
"# press enter key, otherwise notebook will be pending\n",
"def grepFirstLetter():\n",
" word = input()\n",
" firstLetter = word[0]\n",
" return firstLetter\n",
" #print(\"the letter starts with : {}, and will be inserted under the {} leaf\".format(firstLetter, firstLetter))"
]
},
{
"cell_type": "code",
"execution_count": 334,
"id": "11081ff6-0295-4329-885c-6e6ddfddfcbf",
"metadata": {},
"outputs": [],
"source": [
"def insertLeaf(root,firstLetter):\n",
" #create new leaf \n",
" letterLeaf(firstLetter)\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
" # traversal \n",
" # while x != none means the pointer can keep traversing\n",
" while(x != None):\n",
" y = x #trailing pointer points to x \n",
" if (firstLetter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" # insert leaf at root when tree is empty \n",
" if (y == None):\n",
" y = letterLeaf \n",
" # do string comparison, insert at left side of the alphabetTree \n",
" elif (firstLetter < x.letter):\n",
" x.leftAlphabet = letterLeaf\n",
" # insert at right side of the alphabetTree\n",
" else:\n",
" x.rightAlphabet = letterLeaf\n",
" \n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" # ? \n",
" return y\n"
]
},
{
"cell_type": "code",
"execution_count": 335,
"id": "22301756-70e0-4ff7-b9bb-4f59c458058b",
"metadata": {},
"outputs": [],
"source": [
"# print binary tree in 2D copied from sample program\n",
"COUNT = [10]\n",
"def print2DUtil(root, space) :\n",
"\n",
" # Base case\n",
" if (root == None) :\n",
" return\n",
"\n",
" # Increase distance between levels\n",
" space += COUNT[0]\n",
"\n",
" # Process right child first\n",
" print2DUtil(root.rightAlphabet, space)\n",
"\n",
" # Print current node after space\n",
" # count\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
"\n",
" # Process left child\n",
" print2DUtil(root.leftAlphabet, space)\n",
"\n",
"# Wrapper over print2DUtil()\n",
"def print2D(root) :\n",
" \n",
" # space=[0]\n",
" # Pass initial space count as 0\n",
" print2DUtil(root, 0)"
]
},
{
"cell_type": "code",
"execution_count": 336,
"id": "883373d0-cccc-4497-b9ff-af45670cb1ce",
"metadata": {},
"outputs": [],
"source": [
"# A utility function to insert a new\n",
"# Node with given key in BST\n",
"def insert(root, letter):\n",
"\n",
" # Create a new Node containing\n",
" # the new element\n",
" newleaf = letterLeaf(letter)\n",
"\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (letter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (letter < y.letter):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 337,
"id": "0f0bed93-2858-471b-b827-35f66da519b8",
"metadata": {},
"outputs": [],
"source": [
"def Inorder(root) :\n",
"\n",
" if (root == None) :\n",
" return\n",
" else:\n",
" Inorder(root.leftAlphabet)\n",
" print( root.letter, end = \" \" )\n",
" Inorder(root.rightAlphabet)"
]
},
{
"cell_type": "code",
"execution_count": 338,
"id": "e1884b95-8b53-49d6-b56c-a7226f14937e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
"\n",
" z\n",
"\n",
" y\n",
"\n",
" x\n",
"\n",
" w\n",
"\n",
" v\n",
"\n",
" u\n",
"\n",
" t\n",
"\n",
" s\n",
"\n",
" r\n",
"\n",
" q\n",
"\n",
" p\n",
"\n",
" o\n",
"\n",
" n\n",
"\n",
" m\n",
"\n",
" l\n",
"\n",
" k\n",
"\n",
"j\n",
"\n",
" i\n",
"\n",
" h\n",
"\n",
" g\n",
"\n",
" f\n",
"\n",
" e\n",
"\n",
" d\n",
"\n",
" c\n",
"\n",
" b\n",
"\n",
" a\n"
]
}
],
"source": [
"#Driver Code\n",
"import random\n",
"#if __name__ == '__main__':\n",
"\n",
"alphabet = [\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"y\",\"z\"]\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_letter = random.choice(alphabet)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insert(root, random_letter)\n",
"# remove that letter from list\n",
"alphabet.remove(random_letter)\n",
"print(alphabet)\n",
"len_list = (len(alphabet))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_letter = random.choice(alphabet)\n",
" insert(root,random_letter)\n",
" alphabet.remove(random_letter)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations"
]
},
{
"cell_type": "code",
"execution_count": 329,
"id": "d222d70f-2771-45be-9ac1-7ac579a242cb",
"metadata": {},
"outputs": [],
"source": [
"# print a vertical standing tree \n",
"# https://www.geeksforgeeks.org/print-level-order-traversal-line-line/\n",
"# https://www.geeksforgeeks.org/level-order-tree-traversal/"
]
},
{
"cell_type": "code",
"execution_count": 323,
"id": "39d68b3e-064e-4ed6-b10d-c7250a7034e3",
"metadata": {},
"outputs": [],
"source": [
"# a morse code tree\n",
"# https://www.101computing.net/morse-code-using-a-binary-tree/"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f7205015-dd4b-48bf-94c4-be0f96d8988a",
"metadata": {},
"outputs": [],
"source": [
"#firstLetter = grepFirstLetter()\n",
"#print(firstLetter)"
]
}
],
"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
}

340
.ipynb_checkpoints/a_letter_tree_with_hanging_fruits-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,340 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "9da34557-037a-436f-bbaa-d332057cbe18",
"metadata": {},
"source": [
"# a letter tree, with fruits hanging, each starts with a different letter"
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "01acaa97-796a-4e34-9ee3-a46e71493d9d",
"metadata": {},
"outputs": [],
"source": [
"fruit_list = [\"apricot\",\"blood orange\",\"currant\",\"durian\",\"egg fruit\",\"fig\",\"guava\",\n",
" \"hawthorne\",\"jujube\",\"kiwi\",\"lychee\",\"mandarin\",\"nectarine\",\"olive\",\"persimmon\",\"quandong\",\"rambutan\",\"star fruit\",\n",
" \"tangor\",\"ugli fruit\",\"vanilla\",\"water chestnut\",\"ximenia\",\"yuzu\",\"zhe\"]\n",
"# additionally: longan yumberry sugarcane "
]
},
{
"cell_type": "code",
"execution_count": 130,
"id": "08ab8673-9b5c-4bd0-9fac-72796e831b94",
"metadata": {},
"outputs": [],
"source": [
"# build the fruit motley tree with extra utilities than the letter tree"
]
},
{
"cell_type": "code",
"execution_count": 131,
"id": "9c7187e4-0c49-4908-a169-775e6e475f94",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,letter,wordFruit):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.letter = letter\n",
" # try using a list structure to contain the words in this node? \n",
" self.wordFruit = wordFruit"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "11dbf280-6c61-4020-bfe7-e85a723697db",
"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.rightAlphabet, space)\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
" \n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" #print(root.letter) \n",
" print(root.wordFruit)\n",
" # Process left child\n",
" print2DUtil_flat(root.leftAlphabet, 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": 133,
"id": "d0bcd376-491e-48e9-8bd9-e10d91346d7f",
"metadata": {},
"outputs": [],
"source": [
"#the input was for an interactive version like text input used by wang, save for later \n",
"def grepFirstLetter(word):\n",
" #word = input()\n",
" firstLetter = word[0]\n",
" return firstLetter\n",
" #print(\"the letter starts with : {}, and will be inserted under the {} leaf\".format(firstLetter, firstLetter))"
]
},
{
"cell_type": "code",
"execution_count": 134,
"id": "7a12a00f-f7b0-4234-a06c-54c6f3d1daf1",
"metadata": {},
"outputs": [],
"source": [
"# it will be parsed from the fruit basket\n",
"# pick a fruit\n",
"# hang onto tree\n",
"# parse the string letter by using the grepFirstLetter\n",
"def insertLeaf(root,wordFruit):\n",
" #create new leaf \n",
" letter = grepFirstLetter(wordFruit)\n",
" #print(\"first letter of {} is : {} \".format(wordFruit, letter))\n",
" #creating a new node containing firstLetter and wordFruit\n",
" newleaf = letterLeaf(letter,wordFruit)\n",
" #print(\"test print attributes {} {}\".format(newleaf.letter, newleaf.wordFruit))\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (letter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (letter < y.letter):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 135,
"id": "dc2230e9-0831-4e3c-93b8-c96d20fd0525",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"here is a tree that's laying on the ground: \n",
"\n",
" z\n",
" zhe\n",
"\n",
" y\n",
" yuzu\n",
"\n",
" x\n",
" ximenia\n",
"\n",
"w\n",
"water chestnut\n",
"\n",
" v\n",
" vanilla\n",
"\n",
" u\n",
" ugli fruit\n",
"\n",
" t\n",
" tangor\n",
"\n",
" s\n",
" star fruit\n",
"\n",
" r\n",
" rambutan\n",
"\n",
" q\n",
" quandong\n",
"\n",
" p\n",
" persimmon\n",
"\n",
" o\n",
" olive\n",
"\n",
" n\n",
" nectarine\n",
"\n",
" m\n",
" mandarin\n",
"\n",
" l\n",
" lychee\n",
"\n",
" k\n",
" kiwi\n",
"\n",
" j\n",
" jujube\n",
"\n",
" h\n",
" hawthorne\n",
"\n",
" g\n",
" guava\n",
"\n",
" f\n",
" fig\n",
"\n",
" e\n",
" egg fruit\n",
"\n",
" d\n",
" durian\n",
"\n",
" c\n",
" currant\n",
"\n",
" b\n",
" blood orange\n",
"\n",
" a\n",
" apricot\n"
]
}
],
"source": [
"# same deal, insert everything in the list until it's empty \n",
"import random\n",
"\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_fruit = random.choice(fruit_list)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insertLeaf(root, random_fruit)\n",
"# remove that letter from list\n",
"fruit_list.remove(random_fruit)\n",
"#print(fruit_list)\n",
"len_list = (len(fruit_list))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_fruit = random.choice(fruit_list)\n",
" insertLeaf(root,random_fruit)\n",
" fruit_list.remove(random_fruit)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations\n"
]
},
{
"cell_type": "code",
"execution_count": 136,
"id": "6fc4208f-8088-476d-b20d-0f0ac0e85066",
"metadata": {},
"outputs": [],
"source": [
"# fruits in structured presetations:\n",
"# https://zhuanlan.zhihu.com/p/113457497\n",
"# https://www.wordmom.com/fruits/that-start-with-w"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7bd7553d-8ed4-436b-b4cf-99395a4f91b9",
"metadata": {},
"outputs": [],
"source": [
"# more fun stuff\n",
"# https://en.wikipedia.org/wiki/Flora_Sinensis\n"
]
},
{
"cell_type": "markdown",
"id": "5b11e6fc-0443-4373-8530-5f2b2f1b0aa7",
"metadata": {},
"source": [
"During a potluck dinner in Beijing Adel brought an dish made from pomegrante seeds. It was in December, the crowd was not used to the fruit salad dish. Adel was the only Iranian there. A talented cook as Adel was, the dish was barely touched. \n",
"Adel, I think you would agree with me that international potlucks are as bad as they can be. Let's hang the fruits high up - trees are good to store and access memories. For the pomegrantes seeds that I've missed that evening. "
]
}
],
"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
}

383
.ipynb_checkpoints/a_longan_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,383 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "59b5e56e-137c-4c72-8832-3fb7e625fddc",
"metadata": {},
"source": [
"# a longan tree\n",
"# 龙眼树"
]
},
{
"cell_type": "markdown",
"id": "1d3d5765-21b5-4022-8fb6-995feadbd000",
"metadata": {},
"source": [
"## what is longan?\n",
"Dimocarpus longan, commonly known as the longan, is a tropical tree species that produces edible fruit. It is one of the better-known tropical members of the soapberry family Sapindaceae,to which the lychee and rambutan also belong. The fruit of the longan is similar to that of the lychee, but less aromatic in taste."
]
},
{
"cell_type": "markdown",
"id": "8bd7458b-bbb1-4977-9f78-a4f8f2e93985",
"metadata": {},
"source": [
"### a photo of a longan tree with fruits\n",
"from reddit post https://www.reddit.com/r/gardening/comments/8cfh6n/our_glorious_longan_tree/"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "39a00b5f-45ca-4356-ad0e-b2cef2593ef1",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<img src=\"img/longan_tree.jpg\" width=\"400\" height=\"400\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.display import Image\n",
"url_tree = \"images/longan_tree.jpg\"\n",
"Image(url= url_tree, width=400, height=400)"
]
},
{
"cell_type": "markdown",
"id": "547e4b39-856f-4374-a23a-b95917817749",
"metadata": {},
"source": [
"## what is the soapberry family Sapindaceae?\n",
"The Sapindaceae are a family of flowering plants in the order Sapindales known as the soapberry family. \n"
]
},
{
"cell_type": "markdown",
"id": "9a0050aa-eabb-4407-971e-abd89f9ddb17",
"metadata": {},
"source": [
"### why is knowing the soapberry family important for the longan tree"
]
},
{
"cell_type": "markdown",
"id": "68ba1fba-d0f0-4e6f-952b-07ae19262df8",
"metadata": {},
"source": [
"As we know the longan tree is one tree species under the soapberry family, we can track the other tree species relevant to the longan tree. The lychee tree, the rambutan tree, and the longan tree are closely related to each other. "
]
},
{
"cell_type": "markdown",
"id": "0af3e49f-f417-4779-afc8-9932be9539f5",
"metadata": {},
"source": [
"This is written in early spring, and longan fruits are harvested during the summer. In villages in Southern China, harvesting longan fruits \"摘龙眼\"is a fun summer activity. "
]
},
{
"cell_type": "markdown",
"id": "7ba8cd22-532f-424c-8c57-96990a8903fd",
"metadata": {},
"source": [
"Longan also means \"dragon eye\". The fruit is round, resembling an eyeball of a dragon. There is also the \"phoenix eye\"(凤眼),referring to eyes that has a long-ish shape and tilts upwards. "
]
},
{
"cell_type": "markdown",
"id": "3f133efd-1adf-40f0-acb6-24fbff03bebb",
"metadata": {},
"source": [
"In a gender binary context, suppose there is a pair of twins that's a boy and a girl. In Chinese such pair of twins is refered to as \"dragon and phoenix twin\"(龙凤胎)。Suppose the girl has the \"phonenix eyes\"(凤眼), then would the boy eat loads of \"dragon eyes\"(龙眼)?!\n",
"在性别二元对立的语境下，有一对龙凤胎，女孩有一双凤眼，那男孩岂不是有一双龙眼？！"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "23f11815-0327-4027-8e4a-6004595e9525",
"metadata": {},
"outputs": [],
"source": [
"eyes_l = [\"⊙\",\"ಠ\",\"ಡ\",\"⚆\",\n",
" \"✪\",\"◙\",\"*\",\"°\",\n",
" \"☉\",\"⚈\",\"๏\",\"◔\",\n",
" \"◉\",\"ʘ\",\"Θ\",\"❍\",\n",
" \"●\",\"ᓂ\",\"ᓀ\",\"•͈\",\n",
" ]"
]
},
{
"cell_type": "markdown",
"id": "e9181f99-311b-4788-bba1-3781b62dc7f8",
"metadata": {},
"source": [
"## dragon eyes of various affects\n",
"呆萌的龙眼，迟疑的龙眼，左顾右盼的龙眼，闪烁其辞的龙眼。\n",
"被踩扁的龙眼，爆了浆的龙眼，剥开皮的龙眼，被掏空的龙眼。"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "f74f4027-9305-4862-adb9-3bd46bae37ad",
"metadata": {},
"outputs": [],
"source": [
"# build a tree from eyes_l\n",
"# can try a binary tree structure\n",
"# however, a longan tree cannot be arbitrarily defined as using\n",
"# the bst structure\n",
"# are there other tree branching structures to try? "
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "35a275f8-71d4-4354-b019-befc9650c042",
"metadata": {},
"outputs": [],
"source": [
"# starting from a yard of trees: longan, lychee and rombutan "
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "fe8cc549-0ffe-4d55-afb3-a49605fca2c1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"soapberry forest\n",
"├── longan\n",
"├── lychee\n",
"└── rombutan\n"
]
}
],
"source": [
"from anytree import Node, RenderTree\n",
"# build tree\n",
"soapberryForest = Node(\"soapberry forest\")\n",
"longan = Node(\"longan\", parent=soapberryForest)\n",
"lychee = Node(\"lychee\", parent=soapberryForest)\n",
"rombutan = Node(\"rombutan\", parent=soapberryForest)\n",
"\n",
"# print tree\n",
"for pre, fill, node in RenderTree(soapberryForest):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "a651378f-02e3-4da4-8510-3754af471cc2",
"metadata": {},
"outputs": [],
"source": [
"# bst tree template \n",
"\"\"\"Python3 program to demonstrate insert\n",
"operation in binary search tree \"\"\"\n",
"\n",
"# A Binary Tree Node\n",
"# Utility function to create a\n",
"# new tree node\n",
"class newNode:\n",
"\n",
" # Constructor to create a newNode\n",
" def __init__(self, data):\n",
" self.key= data\n",
" self.left = None\n",
" self.right = self.parent = None\n",
"\n",
"# A utility function to insert a new\n",
"# Node with given key in BST\n",
"def insert(root, key):\n",
"\n",
" # Create a new Node containing\n",
" # the new element\n",
" newnode = newNode(key)\n",
"\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (key < x.key):\n",
" x = x.left\n",
" else:\n",
" x = x.right\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newnode\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (key < y.key):\n",
" y.left = newnode\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.right = newnode\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"#Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" root = None\n",
" root = insert(root, \"longan tree\")\n",
" for eye in eyes_l:\n",
" insert(root,eye)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "ef3979c3-7da9-4bb3-a691-4a210da308cb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
" ❍\n",
"\n",
" ✪\n",
"\n",
" ⚈\n",
"\n",
" ⚆\n",
"\n",
" ☉\n",
"\n",
" ◙\n",
"\n",
" ◔\n",
"\n",
" ●\n",
"\n",
" ◉\n",
"\n",
" ⊙\n",
"\n",
" •͈\n",
"\n",
" ᓂ\n",
"\n",
" ᓀ\n",
"\n",
" ๏\n",
"\n",
" ಡ\n",
"\n",
" ಠ\n",
"\n",
" Θ\n",
"\n",
" ʘ\n",
"\n",
" °\n",
"\n",
"longan tree\n",
"\n",
" *\n"
]
}
],
"source": [
"COUNT = [10]\n",
"def print2DUtil(root, space) :\n",
"\n",
" # Base case\n",
" if (root == None) :\n",
" return\n",
"\n",
" # Increase distance between levels\n",
" space += COUNT[0]\n",
"\n",
" # Process right child first\n",
" print2DUtil(root.right, space)\n",
"\n",
" # Print current node after space\n",
" # count\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.key)\n",
"\n",
" # Process left child\n",
" print2DUtil(root.left, space)\n",
"\n",
"# Wrapper over print2DUtil()\n",
"def print2D(root) :\n",
" \n",
" # space=[0]\n",
" # Pass initial space count as 0\n",
" print2DUtil(root, 0)\n",
"\n",
"# Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" \n",
" print2D(root)"
]
},
{
"cell_type": "markdown",
"id": "d8d8b5fa-49cf-47e5-8c69-a0285b286030",
"metadata": {},
"source": [
"a pun, a poem, a puoem. "
]
}
],
"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
}

314
.ipynb_checkpoints/a_morse_code_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,314 @@
{
"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
}

49
.ipynb_checkpoints/a_procedural_morse_code_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,49 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "23070ca4-55cc-4a58-97d5-cb2fcb9c30a2",
"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": "6ca5a800-4180-43bc-9a1c-ba260b9f207a",
"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
}

6
.ipynb_checkpoints/a_radio_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

53
.ipynb_checkpoints/a_raspberry_orange_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,53 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "d620c21c-89d5-4b37-888f-79212671d7db",
"metadata": {},
"source": [
"# a raspberry orange tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "343265dc-49bd-4220-96aa-3ed2fbd1a54e",
"metadata": {},
"outputs": [],
"source": [
"# https://www.reddit.com/r/aldi/comments/kqxzuc/the_raspberry_oranges_are_wonderful/"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f519c19c-03f2-4332-be12-fd3beab81cb7",
"metadata": {},
"outputs": [],
"source": [
"# pigment is shared between the raspberry species and the raspberry orange species"
]
}
],
"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
}

6
.ipynb_checkpoints/a_reddit_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

186
.ipynb_checkpoints/a_sample_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,186 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "2363b275-a2e8-429b-94f2-e645178b38f1",
"metadata": {},
"outputs": [],
"source": [
"\"\"\"Python3 program to demonstrate insert\n",
"operation in binary search tree \"\"\"\n",
"\n",
"# A Binary Tree Node\n",
"# Utility function to create a\n",
"# new tree node\n",
"class newNode:\n",
"\n",
" # Constructor to create a newNode\n",
" def __init__(self, data):\n",
" self.key= data\n",
" self.left = None\n",
" self.right = self.parent = None\n",
"\n",
"# A utility function to insert a new\n",
"# Node with given key in BST\n",
"def insert(root, key):\n",
"\n",
" # Create a new Node containing\n",
" # the new element\n",
" newnode = newNode(key)\n",
"\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (key < x.key):\n",
" x = x.left\n",
" else:\n",
" x = x.right\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newnode\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (key < y.key):\n",
" y.left = newnode\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.right = newnode\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST\n",
"def Inorder(root) :\n",
"\n",
" if (root == None) :\n",
" return\n",
" else:\n",
" Inorder(root.left)\n",
" print( root.key, end = \" \" )\n",
" Inorder(root.right)\n",
"\n",
"#Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" root = None\n",
" root = insert(root, \"m\")\n",
" insert(root, \"n\")\n",
" insert(root, \"l\")\n",
" insert(root, \"p\")\n",
" insert(root, \"q\")\n",
" insert(root, \"a\")\n",
" insert(root, \"b\")\n",
"\n",
"\n",
" # Pr inorder traversal of the BST\n",
"\n",
"\n",
"# This code is contributed by\n",
"# SHUBHAMSINGH10"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "921f4017-3f1f-4085-8da8-cc850fbd4c6e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
" q\n",
"\n",
" p\n",
"\n",
" n\n",
"\n",
"m\n",
"\n",
" l\n",
"\n",
" b\n",
"\n",
" a\n"
]
}
],
"source": [
"# print binary tree in 2D copied from sample program\n",
"COUNT = [10]\n",
"def print2DUtil(root, space) :\n",
"\n",
" # Base case\n",
" if (root == None) :\n",
" return\n",
"\n",
" # Increase distance between levels\n",
" space += COUNT[0]\n",
"\n",
" # Process right child first\n",
" print2DUtil(root.right, space)\n",
"\n",
" # Print current node after space\n",
" # count\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.key)\n",
"\n",
" # Process left child\n",
" print2DUtil(root.left, space)\n",
"\n",
"# Wrapper over print2DUtil()\n",
"def print2D(root) :\n",
" \n",
" # space=[0]\n",
" # Pass initial space count as 0\n",
" print2DUtil(root, 0)\n",
"\n",
"# Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" \n",
" print2D(root)"
]
}
],
"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
}

6
.ipynb_checkpoints/a_tree_of_trees-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

329
.ipynb_checkpoints/a_tree_scraping_from_web-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,329 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "9da34557-037a-436f-bbaa-d332057cbe18",
"metadata": {},
"source": [
"a tree extending to the web, pasted with images of the named fruit. the process is done by making a request to the web and scraping an image returned from the request. "
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "01acaa97-796a-4e34-9ee3-a46e71493d9d",
"metadata": {},
"outputs": [],
"source": [
"fruit_list = [\"apricot\",\"blood orange\",\"currant\",\"durian\",\"egg fruit\",\"fig\",\"guava\",\n",
" \"hawthorne\",\"jujube\",\"kiwi\",\"lychee\",\"mandarin\",\"nectarine\",\"olive\",\"persimmon\",\"quandong\",\"rambutan\",\"star fruit\",\n",
" \"tangor\",\"ugli fruit\",\"vanilla\",\"water chestnut\",\"ximenia\",\"yuzu\",\"zhe\"]\n",
"# additionally: longan yumberry sugarcane "
]
},
{
"cell_type": "code",
"execution_count": 130,
"id": "08ab8673-9b5c-4bd0-9fac-72796e831b94",
"metadata": {},
"outputs": [],
"source": [
"# build the fruit motley tree with extra utilities than the letter tree"
]
},
{
"cell_type": "code",
"execution_count": 131,
"id": "9c7187e4-0c49-4908-a169-775e6e475f94",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,letter,wordFruit):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.letter = letter\n",
" # try using a list structure to contain the words in this node? \n",
" self.wordFruit = wordFruit"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "11dbf280-6c61-4020-bfe7-e85a723697db",
"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.rightAlphabet, space)\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
" \n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" #print(root.letter) \n",
" print(root.wordFruit)\n",
" # Process left child\n",
" print2DUtil_flat(root.leftAlphabet, 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": 133,
"id": "d0bcd376-491e-48e9-8bd9-e10d91346d7f",
"metadata": {},
"outputs": [],
"source": [
"#the input was for an interactive version like text input used by wang, save for later \n",
"def grepFirstLetter(word):\n",
" #word = input()\n",
" firstLetter = word[0]\n",
" return firstLetter\n",
" #print(\"the letter starts with : {}, and will be inserted under the {} leaf\".format(firstLetter, firstLetter))"
]
},
{
"cell_type": "code",
"execution_count": 134,
"id": "7a12a00f-f7b0-4234-a06c-54c6f3d1daf1",
"metadata": {},
"outputs": [],
"source": [
"# it will be parsed from the fruit basket\n",
"# pick a fruit\n",
"# hang onto tree\n",
"# parse the string letter by using the grepFirstLetter\n",
"def insertLeaf(root,wordFruit):\n",
" #create new leaf \n",
" letter = grepFirstLetter(wordFruit)\n",
" #print(\"first letter of {} is : {} \".format(wordFruit, letter))\n",
" #creating a new node containing firstLetter and wordFruit\n",
" newleaf = letterLeaf(letter,wordFruit)\n",
" #print(\"test print attributes {} {}\".format(newleaf.letter, newleaf.wordFruit))\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (letter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (letter < y.letter):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 135,
"id": "dc2230e9-0831-4e3c-93b8-c96d20fd0525",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"here is a tree that's laying on the ground: \n",
"\n",
" z\n",
" zhe\n",
"\n",
" y\n",
" yuzu\n",
"\n",
" x\n",
" ximenia\n",
"\n",
"w\n",
"water chestnut\n",
"\n",
" v\n",
" vanilla\n",
"\n",
" u\n",
" ugli fruit\n",
"\n",
" t\n",
" tangor\n",
"\n",
" s\n",
" star fruit\n",
"\n",
" r\n",
" rambutan\n",
"\n",
" q\n",
" quandong\n",
"\n",
" p\n",
" persimmon\n",
"\n",
" o\n",
" olive\n",
"\n",
" n\n",
" nectarine\n",
"\n",
" m\n",
" mandarin\n",
"\n",
" l\n",
" lychee\n",
"\n",
" k\n",
" kiwi\n",
"\n",
" j\n",
" jujube\n",
"\n",
" h\n",
" hawthorne\n",
"\n",
" g\n",
" guava\n",
"\n",
" f\n",
" fig\n",
"\n",
" e\n",
" egg fruit\n",
"\n",
" d\n",
" durian\n",
"\n",
" c\n",
" currant\n",
"\n",
" b\n",
" blood orange\n",
"\n",
" a\n",
" apricot\n"
]
}
],
"source": [
"# same deal, insert everything in the list until it's empty \n",
"import random\n",
"\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_fruit = random.choice(fruit_list)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insertLeaf(root, random_fruit)\n",
"# remove that letter from list\n",
"fruit_list.remove(random_fruit)\n",
"#print(fruit_list)\n",
"len_list = (len(fruit_list))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_fruit = random.choice(fruit_list)\n",
" insertLeaf(root,random_fruit)\n",
" fruit_list.remove(random_fruit)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations\n"
]
},
{
"cell_type": "code",
"execution_count": 136,
"id": "6fc4208f-8088-476d-b20d-0f0ac0e85066",
"metadata": {},
"outputs": [],
"source": [
"# fruits in structured presetations:\n",
"# https://zhuanlan.zhihu.com/p/113457497\n",
"# https://www.wordmom.com/fruits/that-start-with-w"
]
},
{
"cell_type": "markdown",
"id": "5b11e6fc-0443-4373-8530-5f2b2f1b0aa7",
"metadata": {},
"source": [
"During a potluck dinner in Beijing Adel brought an dish made from pomegrante seeds. It was in December, the crowd was not used to the fruit salad dish. Adel was the only Iranian there. A talented cook as Adel was, the dish was barely touched. \n",
"Adel, I think you would agree with me that international potlucks are as bad as they can be. Let's hang the fruits high up - trees are good to store and access memories. For the pomegrantes seeds that I've missed that evening. "
]
}
],
"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
}

49
.ipynb_checkpoints/a_trident_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,49 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "1cb5571e-af37-47eb-ba2d-5c10c87fbb9e",
"metadata": {},
"outputs": [],
"source": [
"class tridentLeaf:\n",
" def __init__(self,something,somethingelse):\n",
" self.leftProng = None\n",
" self.middleProng = None\n",
" self.rightProng = None\n",
" self.something = something\n",
" self.somethingelse = somethingelse"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6c797c5b-e7e0-432f-9a85-27e7c6e1bdc9",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

6
.ipynb_checkpoints/a_willow_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

6
.ipynb_checkpoints/an_evolutionary_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

6
.ipynb_checkpoints/an_html_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

6
.ipynb_checkpoints/an_nlp_tree-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

6
.ipynb_checkpoints/read_img_folder-checkpoint.ipynb
Unescape Escape View File

@ -0,0 +1,6 @@
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 5
}

BIN
How-to-construct-a-Phylogenetic-tree.jpg
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 57 KiB

12
READTREES.md
Unescape Escape View File

@ -0,0 +1,12 @@
# ABOUT
A series of programs that builds on the tree structure, an abstract data
type used for presenting, storing and searching information
# VALUE IN MEDIA ARCHAEOLOGY
# VALUE IN CRITICAL STUDIES
# FORMAT
Textual outputs are stored as txt files, and image outputs are stored as image files. The program process is stored in Jupyter Notebooks.
# WHERE IS THIS FORKED FROM
# FORK YOUR OWN

303
a_bonary_tree.ipynb
Unescape Escape View File

@ -0,0 +1,303 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# a bonary tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#***********************************************************************\n",
"#** a bo-binary tree *\n",
"#** for and inspired by Wang Xiaobo (1952-1997), writer and programmer.*\n",
"#** \"我也自做了词组功能，是棵B树，我觉得自写的软件自用，感觉是最好的。\" *\n",
"#** \"I created a word feature with a binary tree strucutre, *\n",
"#** and I feel best about using a program you created yourself.\" *\n",
"#** read more in archival documentation(Chinese): *\n",
"#** https://blog.csdn.net/weixin_33697898/article/details/93356187 *\n",
"#** *\n",
"#***********************************************************************"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 思维的乐趣 \n",
"### on discourse \n",
"### quotes from 《我的精神家园》\n",
"谈到思想的乐趣，我就想到我父亲的遭遇。我父亲是一位哲学教授，在五六十年代从事思维史的研究。在老年时，他告诉我自己一生的学术经历，就如一部恐怖电影。每当他企图立论时，总要在大一统的思想体系里找到自己的位置，就如一只老母鸡要在一个大搬家的宅院里找地方孵蛋一样。结果他虽然热爱科学而且很努力，在一生中却没有得到思维的乐趣，之收获了无数的恐慌。他一生的探索，只剩下了一些断壁残垣，收到一本名为《逻辑探索》的书里，在他身后出版。\n",
"\n",
"我在沉默中过了很多年：插队、当工人、当大学生，后来又在大学里任过教。当教师的人保持沉默似不可能，但我教的是技术性的课程，在讲台上只讲技术性的话，下了课我就走人。找我看，不管干什么都可以保持沉默。当然，我还有一个终身爱好，就是写小说。但是写好了不拿去发表，同样也保持了沉默。至于沉默的理由，很是简单。那就是信不过话语圈。从我短短的人生经历看，它是一座声名狼藉的疯人院。当时我怀疑的不是说过亩产三十万斤粮、炸过精神原子弹的那个话语圈，而是一切话语圈子。\n",
"\n",
"还有一些人，因为种种原因，对于话语的世界有某种厌恶之情。我属于这最后一种。作为最后一种人，也有义务谈自己的所见所闻。\n",
"\n",
"王小波（1997).《我的精神家园》.北京：文化艺术出版社.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Create a proof of concept dictionary tree that looks for hong(3) fu(2)"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from anytree import Node, RenderTree\n",
"h = Node(\"h\")\n",
"o = Node(\"o\", parent=h)\n",
"n = Node(\"n\", parent=o)\n",
"g = Node(\"g\", parent=n)\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Node('/h')\n",
"Node('/h/o/n/g')\n",
"h\n",
"└── o\n",
" └── n\n",
" └── g\n"
]
}
],
"source": [
"#print node\n",
"print(h)\n",
"print(g)\n",
"\n",
"#print tree\n",
"for pre, fill, node in RenderTree(h):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"f\n",
"└── u\n"
]
}
],
"source": [
"f = Node(\"f\")\n",
"u = Node(\"u\", parent = f)\n",
"for pre, fill, node in RenderTree(f):\n",
"\tprint(\"%s%s\" %(pre,node.name))\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"y\n",
"└── e\n"
]
}
],
"source": [
"y = Node(\"y\")\n",
"e = Node(\"e\", parent = y)\n",
"for pre, fill, node in RenderTree(y):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"b\n",
"└── e\n",
" └── n\n"
]
}
],
"source": [
"b = Node(\"b\")\n",
"e = Node(\"e\", parent = b)\n",
"n = Node(\"n\", parent = e)\n",
"for pre, fill, node in RenderTree(b):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def printTree(root):\n",
" for pre, fill, node in RenderTree(root):\n",
" print(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"h\n",
"└── o\n",
" └── n\n",
" └── g\n",
"红\n",
"\n",
"f\n",
"└── u\n",
"拂\n",
"\n",
"y\n",
"└── e\n",
"夜\n",
"\n",
"b\n",
"└── e\n",
" └── n\n",
"奔\n",
"\n"
]
}
],
"source": [
"tree_list = [h,f,y,b]\n",
"红拂夜奔 = [\"红\",\"拂\",\"夜\",\"奔\"]\n",
"counter = 0\n",
"for tree in tree_list:\n",
" printTree(tree)\n",
" print(红拂夜奔[counter])\n",
" counter = counter + 1\n",
" print()"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# an alphabet binary search tree\n",
"import string\n",
"alphabet_s = string.ascii_lowercase\n",
"alphabet_l = list(alphabet_s)\n",
"#print(alphabet_l)\n",
"# add nodes manually, starting from m "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<video src=\"vid/wang_interview.mp4\" controls >\n",
" Your browser does not support the <code>video</code> element.\n",
" </video>"
],
"text/plain": [
"<IPython.core.display.Video object>"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import IPython.display \n",
"Video('vid/wang_interview.mp4')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# transcription of wang's interview in Chinese\n",
"# autotranslate that into English for non-Chinese readers"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"数据结构是思维的形状的一种表现方式\n",
"the structure of data may be one representation of the form of thought "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wang Xiaobo (1952-1997), writer and programmer. <br>\n",
"\"我也自做了词组功能，是棵B树，我觉得自写的软件自用，感觉是最好的。\" <br>\n",
"\"I created a word feature with a binary tree strucutre, and I feel best about using a program you created yourself.\"\n",
"read more in archival documentation(Chinese):<br>\n",
"https://blog.csdn.net/weixin_33697898/article/details/93356187"
]
}
],
"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": 4
}

79
a_conversation_tree.ipynb
Unescape Escape View File

@ -0,0 +1,79 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "666a35e1-435d-4555-8193-9258ff568e21",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,question):\n",
" self.yes = None\n",
" self.no = None\n",
" self.question = question\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "254b714a-2504-4cc0-9a78-21d406ddbb2f",
"metadata": {},
"outputs": [],
"source": [
"# tree traversals, here to print stuff \n",
"def inorder(treeName):\n",
" if treeName:\n",
" inorder(treeName.yes)\n",
" print(treeName.question)\n",
" inorder(treeName.no)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e8512457-7944-4604-92c7-29f90ab6c3db",
"metadata": {},
"outputs": [],
"source": [
"# interactive user input utility \n",
"def saysYes(ques):\n",
" while True:\n",
" ans = input(ques)\n",
" ans = ans[0:1].lower()\n",
" if ans == 'y': return True\n",
" else : return False"
]
},
{
"cell_type": "markdown",
"id": "8415d1d2-211a-4e82-b331-85527e8c1510",
"metadata": {},
"source": [
"reference\n",
"https://web.stonehill.edu/compsci/CS211/Assignmenta%202015/TreeAssignment.pdf"
]
}
],
"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
}

0
a_feminist_tree.ipynb
Unescape Escape View File

750
a_fruit_tree_with_hanging_pictures.ipynb
Unescape Escape View File

@ -0,0 +1,750 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "9da34557-037a-436f-bbaa-d332057cbe18",
"metadata": {},
"source": [
"# a fruit tree with a variety of fruits hanging, each enclosed in a picture frame. "
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "01acaa97-796a-4e34-9ee3-a46e71493d9d",
"metadata": {},
"outputs": [],
"source": [
"fruit_list = [\"apricot\",\"blood_orange\",\"currant\",\"durian\",\"egg_fruit\",\"fig\",\"guava\",\n",
" \"hawthorne\",\"jujube\",\"kiwi\",\"lychee\",\"mandarin\",\"nectarine\",\"olive\",\"persimmon\",\"quandong\",\"rambutan\",\"star_fruit\",\n",
" \"tangor\",\"ugli_fruit\",\"vanilla\",\"water_chestnut\",\"ximenia\",\"yuzu\",\"zhe\"]\n",
"# additionally: longan yumberry sugarcane "
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "08ab8673-9b5c-4bd0-9fac-72796e831b94",
"metadata": {},
"outputs": [],
"source": [
"# build the fruit motley tree with extra utilities than the letter tree"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "9c7187e4-0c49-4908-a169-775e6e475f94",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,wordFruit,path):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.wordFruit = wordFruit\n",
" # try using a list structure to contain the words in this node? \n",
" self.path = path"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "11dbf280-6c61-4020-bfe7-e85a723697db",
"metadata": {},
"outputs": [],
"source": [
"# printing tree utility \n",
"# the display cannot indent?\n",
"from IPython.display import Image\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",
" print2DUtil_flat(root.rightAlphabet, space)\n",
" print()\n",
" \n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" url_tree = root.path\n",
" i = Image(url= url_tree, width=30, height=30)\n",
" display(i)\n",
"\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.wordFruit)\n",
" print2DUtil_flat(root.leftAlphabet, 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",
" # import image module\n",
" # get the image\n",
" print2DUtil_flat(root, 0)\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "d0bcd376-491e-48e9-8bd9-e10d91346d7f",
"metadata": {},
"outputs": [],
"source": [
"def urljoin(wordFruit):\n",
" url = \"images/pic_tree_fruit_img/\" + wordFruit + \".png\"\n",
" return url "
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "7a12a00f-f7b0-4234-a06c-54c6f3d1daf1",
"metadata": {},
"outputs": [],
"source": [
"def insertLeaf(root,wordFruit):\n",
" #create new leaf \n",
" url = urljoin(wordFruit)\n",
" newleaf = letterLeaf(wordFruit,url)\n",
" #print(\"creating leaf with word = {} url = {}\".format(newleaf.wordFruit,newleaf.path))\n",
"\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (wordFruit < x.wordFruit):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (wordFruit < y.wordFruit):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "dc2230e9-0831-4e3c-93b8-c96d20fd0525",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"here is a tree that's laying on the ground: \n",
"\n"
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/zhe.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"zhe\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/yuzu.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" yuzu\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/ximenia.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" ximenia\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/water_chestnut.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" water_chestnut\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/vanilla.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" vanilla\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/ugli_fruit.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" ugli_fruit\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/tangor.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" tangor\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/star_fruit.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" star_fruit\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/rambutan.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" rambutan\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/quandong.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" quandong\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/persimmon.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" persimmon\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/olive.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" olive\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/nectarine.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" nectarine\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/mandarin.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" mandarin\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/lychee.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" lychee\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/kiwi.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" kiwi\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/jujube.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" jujube\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/hawthorne.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" hawthorne\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/guava.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" guava\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/fig.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" fig\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/egg_fruit.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" egg_fruit\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/durian.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" durian\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/currant.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" currant\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/blood_orange.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" blood_orange\n",
"\n",
" "
]
},
{
"data": {
"text/html": [
"<img src=\"images/pic_tree_fruit_img/apricot.png\" width=\"30\" height=\"30\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" apricot\n"
]
}
],
"source": [
"# same deal, insert everything in the list until it's empty \n",
"import random\n",
"\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_fruit = random.choice(fruit_list)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insertLeaf(root, random_fruit)\n",
"# remove that letter from list\n",
"fruit_list.remove(random_fruit)\n",
"#print(fruit_list)\n",
"len_list = (len(fruit_list))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_fruit = random.choice(fruit_list)\n",
" insertLeaf(root,random_fruit)\n",
" fruit_list.remove(random_fruit)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations\n"
]
}
],
"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
}

33
a_genetic_tree.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "b8bb6f10-0461-4fb9-9f36-9b64ae33405c",
"metadata": {},
"source": [
"# a genetic tree"
]
}
],
"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
}

405
a_letter_tree.ipynb
Unescape Escape View File

@ -0,0 +1,405 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "4708c5dc-a1e8-42e2-8702-ecea9513d54b",
"metadata": {},
"source": [
"# a binary tree of leaves of letters"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "906fc548-a2a5-411b-ad60-9e93e88bf7f5",
"metadata": {},
"outputs": [],
"source": [
"# http://syllabus.cs.manchester.ac.uk/ugt/2021/COMP26912/lab/ex5.html\n",
"# https://web.stanford.edu/class/archive/cs/cs106x/cs106x.1174/assn/twentyOneQuestions.html\n",
"# https://www.openbookproject.net/py4fun/animal/animal.html"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "578e93f8-e04f-4b01-a482-ebc78cf2c103",
"metadata": {},
"outputs": [],
"source": [
"# each leaf stores a letter to be asked\n",
"class letterLeaf:\n",
" def __init__(self,letter):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.letter = letter\n",
" # try using a list structure to contain the words in this node? \n",
" self.words = []"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "fa8e3d45-ea21-47e1-9a5a-256e5e7ebed1",
"metadata": {},
"outputs": [],
"source": [
"# tree traversals, here to print stuff \n",
"def inorder(treeName):\n",
" if treeName:\n",
" inorder(treeName.leftAlphabet)\n",
" print(treeName.letter)\n",
" inorder(treeName.rightAlphabet)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "0c75f820-46c4-46af-b5d9-b837cb055b55",
"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.rightAlphabet, space)\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
" # Process left child\n",
" print2DUtil_flat(root.leftAlphabet, 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": 9,
"id": "5f27d6d6-3019-4714-98d0-9650f1e087bb",
"metadata": {},
"outputs": [],
"source": [
"# utility to read the first letter of the input word \n",
"# press enter key, otherwise notebook will be pending\n",
"def grepFirstLetter():\n",
" word = input()\n",
" firstLetter = word[0]\n",
" return firstLetter\n",
" #print(\"the letter starts with : {}, and will be inserted under the {} leaf\".format(firstLetter, firstLetter))"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "11081ff6-0295-4329-885c-6e6ddfddfcbf",
"metadata": {},
"outputs": [],
"source": [
"def insertLeaf(root,firstLetter):\n",
" #create new leaf \n",
" letterLeaf(firstLetter)\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
" # traversal \n",
" # while x != none means the pointer can keep traversing\n",
" while(x != None):\n",
" y = x #trailing pointer points to x \n",
" if (firstLetter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" # insert leaf at root when tree is empty \n",
" if (y == None):\n",
" y = letterLeaf \n",
" # do string comparison, insert at left side of the alphabetTree \n",
" elif (firstLetter < x.letter):\n",
" x.leftAlphabet = letterLeaf\n",
" # insert at right side of the alphabetTree\n",
" else:\n",
" x.rightAlphabet = letterLeaf\n",
" return y\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "22301756-70e0-4ff7-b9bb-4f59c458058b",
"metadata": {},
"outputs": [],
"source": [
"# print binary tree in 2D copied from sample program\n",
"COUNT = [10]\n",
"def print2DUtil(root, space) :\n",
"\n",
" # Base case\n",
" if (root == None) :\n",
" return\n",
"\n",
" # Increase distance between levels\n",
" space += COUNT[0]\n",
"\n",
" # Process right child first\n",
" print2DUtil(root.rightAlphabet, space)\n",
"\n",
" # Print current node after space\n",
" # count\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
"\n",
" # Process left child\n",
" print2DUtil(root.leftAlphabet, space)\n",
"\n",
"# Wrapper over print2DUtil()\n",
"def print2D(root) :\n",
" \n",
" # space=[0]\n",
" # Pass initial space count as 0\n",
" print2DUtil(root, 0)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "883373d0-cccc-4497-b9ff-af45670cb1ce",
"metadata": {},
"outputs": [],
"source": [
"# A utility function to insert a new\n",
"# Node with given key in BST\n",
"def insert(root, letter):\n",
"\n",
" # Create a new Node containing\n",
" # the new element\n",
" newleaf = letterLeaf(letter)\n",
"\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (letter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (letter < y.letter):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "0f0bed93-2858-471b-b827-35f66da519b8",
"metadata": {},
"outputs": [],
"source": [
"def Inorder(root) :\n",
"\n",
" if (root == None) :\n",
" return\n",
" else:\n",
" Inorder(root.leftAlphabet)\n",
" print( root.letter, end = \" \" )\n",
" Inorder(root.rightAlphabet)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "e1884b95-8b53-49d6-b56c-a7226f14937e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'w', 'x', 'y', 'z']\n",
"\n",
" z\n",
"\n",
" y\n",
"\n",
" x\n",
"\n",
" w\n",
"\n",
"v\n",
"\n",
" u\n",
"\n",
" t\n",
"\n",
" s\n",
"\n",
" r\n",
"\n",
" q\n",
"\n",
" p\n",
"\n",
" o\n",
"\n",
" n\n",
"\n",
" m\n",
"\n",
" l\n",
"\n",
" k\n",
"\n",
" j\n",
"\n",
" i\n",
"\n",
" h\n",
"\n",
" g\n",
"\n",
" f\n",
"\n",
" e\n",
"\n",
" d\n",
"\n",
" c\n",
"\n",
" b\n",
"\n",
" a\n"
]
}
],
"source": [
"#Driver Code\n",
"import random\n",
"#if __name__ == '__main__':\n",
"\n",
"alphabet = [\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"y\",\"z\"]\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_letter = random.choice(alphabet)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insert(root, random_letter)\n",
"# remove that letter from list\n",
"alphabet.remove(random_letter)\n",
"print(alphabet)\n",
"len_list = (len(alphabet))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_letter = random.choice(alphabet)\n",
" insert(root,random_letter)\n",
" alphabet.remove(random_letter)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations"
]
},
{
"cell_type": "code",
"execution_count": 329,
"id": "d222d70f-2771-45be-9ac1-7ac579a242cb",
"metadata": {},
"outputs": [],
"source": [
"# print a vertical standing tree \n",
"# https://www.geeksforgeeks.org/print-level-order-traversal-line-line/\n",
"# https://www.geeksforgeeks.org/level-order-tree-traversal/"
]
},
{
"cell_type": "code",
"execution_count": 323,
"id": "39d68b3e-064e-4ed6-b10d-c7250a7034e3",
"metadata": {},
"outputs": [],
"source": [
"# a morse code tree\n",
"# https://www.101computing.net/morse-code-using-a-binary-tree/"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f7205015-dd4b-48bf-94c4-be0f96d8988a",
"metadata": {},
"outputs": [],
"source": [
"#firstLetter = grepFirstLetter()\n",
"#print(firstLetter)"
]
}
],
"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
}

90
a_letter_tree.py
Unescape Escape View File

@ -0,0 +1,90 @@
import time
fruit_list = ["apricot","blood orange","currant","durian","egg fruit","fig","guava",
"hawthorne","jujube","kiwi","lychee","mandarin","nectarine","olive","persimmon","quandong","rambutan","star fruit",
"tangor","ugli fruit","vanilla","water chestnut","ximenia","yuzu","zhe"]
class letterLeaf:
def __init__(self,letter,wordFruit):
self.leftAlphabet = None
self.rightAlphabet = None
self.letter = letter
self.wordFruit = wordFruit
COUNT = [10]
def print2DUtil_flat(root, space,growth_rate):
if (root == None) :
return
space += COUNT[0]
print2DUtil_flat(root.rightAlphabet, space,growth_rate)
print()
for i in range(COUNT[0], space):
print(end = " ")
print(root.letter)
for i in range(COUNT[0], space):
print(end = " ")
print(root.wordFruit)
time.sleep(growth_rate)
print2DUtil_flat(root.leftAlphabet, space,growth_rate)
def print2D(root, growth_rate):
print("here is a tree that's laying on the ground: ")
print2DUtil_flat(root, 0, growth_rate)
def grepFirstLetter(word):
firstLetter = word[0]
return firstLetter
def insertLeaf(root,wordFruit):
letter = grepFirstLetter(wordFruit)
newleaf = letterLeaf(letter,wordFruit)
x = root
y = None
while (x != None):
y = x
if (letter < x.letter):
x = x.leftAlphabet
else:
x = x.rightAlphabet
if (y == None):
y = newleaf
elif (letter < y.letter):
y.leftAlphabet = newleaf
else:
y.rightAlphabet = newleaf
return y
import random
root = None
random_fruit = random.choice(fruit_list)
root = insertLeaf(root, random_fruit)
fruit_list.remove(random_fruit)
len_list = (len(fruit_list))
while len_list > 0:
random_fruit = random.choice(fruit_list)
insertLeaf(root,random_fruit)
fruit_list.remove(random_fruit)
len_list -= 1
def ask_input():
growth_rate = int(input("Enter growth rate value for tree in seconds: "))
return growth_rate
growth_rate = ask_input()
print2D(root, growth_rate)

26
a_letter_tree_web.html
Unescape Escape View File

@ -0,0 +1,26 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
<script defer src="https://pyscript.net/alpha/pyscript.js"></script>
<link rel="stylesheet" type="text/css" href="style.css" />
</head>
<body>
<title> A Letter Tree </title>
<h1> A Letter Tree </h1>
<body>
<div id="console-embed"></div>
<!-- adjust trinket iframe style> <-->
<iframe src="https://trinket.io/embed/python3/3e17f35d95?start=result" width="100%" height="600" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen></iframe>
<div>Layout created by recursive process:
<img src="fig_18_1.png">
Source: Metamagical Themas, pt4, Structure and strangeness.
</div>
</body>
</body>
</html>

111
a_letter_tree_web.py
Unescape Escape View File

@ -0,0 +1,111 @@
from cgitb import html
import time
fruit_list = ["apricot","blood orange","currant","durian","egg fruit","fig","guava",
"hawthorne","jujube","kiwi","lychee","mandarin","nectarine","olive","persimmon","quandong","rambutan","star fruit",
"tangor","ugli fruit","vanilla","water chestnut","ximenia","yuzu","zhe"]
class letterLeaf:
def __init__(self,letter,wordFruit):
self.leftAlphabet = None
self.rightAlphabet = None
self.letter = letter
self.wordFruit = wordFruit
COUNT = [3]
empty_string = " "
def print2DUtil_flat(root, space, growth_rate, html_file):
if (root == None) :
return
space += COUNT[0]
print2DUtil_flat(root.rightAlphabet, space,growth_rate, html_file)
html_file.write("<span>")
#for i in range(COUNT[0], space):
# html_file.write(" ")
html_file.write(root.letter + "<br>")
html_file.write("</span>")
html_file.write("\n")
html_file.write(root.wordFruit + "<br>")
html_file.write("\n")
print2DUtil_flat(root.leftAlphabet, space, growth_rate, html_file)
def print2D(root, growth_rate, html_file):
print("here is a tree that's laying on the ground: ")
print2DUtil_flat(root, 0, growth_rate, html_file)
def grepFirstLetter(word):
firstLetter = word[0]
return firstLetter
def insertLeaf(root,wordFruit):
letter = grepFirstLetter(wordFruit)
newleaf = letterLeaf(letter,wordFruit)
x = root
y = None
while (x != None):
y = x
if (letter < x.letter):
x = x.leftAlphabet
else:
x = x.rightAlphabet
if (y == None):
y = newleaf
elif (letter < y.letter):
y.leftAlphabet = newleaf
else:
y.rightAlphabet = newleaf
return y
import random
root = None
random_fruit = random.choice(fruit_list)
root = insertLeaf(root, random_fruit)
fruit_list.remove(random_fruit)
len_list = (len(fruit_list))
while len_list > 0:
random_fruit = random.choice(fruit_list)
insertLeaf(root,random_fruit)
fruit_list.remove(random_fruit)
len_list -= 1
def ask_input():
growth_rate = int(input("Enter growth rate value for tree in seconds: "))
return growth_rate
growth_rate = ask_input()
html_file = open("a_letter_tree_web.html","w")
html_file.write("<html>\n<head>\n")
html_file.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n")
html_file.write("<link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\" />\n")
html_file.write("</head>\n")
html_file.write("<body>\n")
html_file.write("<title> A Letter Tree </title>\n")
html_file.write("<h1> A Letter Tree </h1>")
print2D(root, growth_rate, html_file)
html_file.write("\n</body>\n</html>")
html_file.close()

340
a_letter_tree_with_hanging_fruits.ipynb
Unescape Escape View File

@ -0,0 +1,340 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "9da34557-037a-436f-bbaa-d332057cbe18",
"metadata": {},
"source": [
"# a letter tree, with fruits hanging, each starts with a different letter"
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "01acaa97-796a-4e34-9ee3-a46e71493d9d",
"metadata": {},
"outputs": [],
"source": [
"fruit_list = [\"apricot\",\"blood orange\",\"currant\",\"durian\",\"egg fruit\",\"fig\",\"guava\",\n",
" \"hawthorne\",\"jujube\",\"kiwi\",\"lychee\",\"mandarin\",\"nectarine\",\"olive\",\"persimmon\",\"quandong\",\"rambutan\",\"star fruit\",\n",
" \"tangor\",\"ugli fruit\",\"vanilla\",\"water chestnut\",\"ximenia\",\"yuzu\",\"zhe\"]\n",
"# additionally: longan yumberry sugarcane "
]
},
{
"cell_type": "code",
"execution_count": 130,
"id": "08ab8673-9b5c-4bd0-9fac-72796e831b94",
"metadata": {},
"outputs": [],
"source": [
"# build the fruit motley tree with extra utilities than the letter tree"
]
},
{
"cell_type": "code",
"execution_count": 131,
"id": "9c7187e4-0c49-4908-a169-775e6e475f94",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,letter,wordFruit):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.letter = letter\n",
" # try using a list structure to contain the words in this node? \n",
" self.wordFruit = wordFruit"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "11dbf280-6c61-4020-bfe7-e85a723697db",
"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.rightAlphabet, space)\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
" \n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" #print(root.letter) \n",
" print(root.wordFruit)\n",
" # Process left child\n",
" print2DUtil_flat(root.leftAlphabet, 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": 133,
"id": "d0bcd376-491e-48e9-8bd9-e10d91346d7f",
"metadata": {},
"outputs": [],
"source": [
"#the input was for an interactive version like text input used by wang, save for later \n",
"def grepFirstLetter(word):\n",
" #word = input()\n",
" firstLetter = word[0]\n",
" return firstLetter\n",
" #print(\"the letter starts with : {}, and will be inserted under the {} leaf\".format(firstLetter, firstLetter))"
]
},
{
"cell_type": "code",
"execution_count": 134,
"id": "7a12a00f-f7b0-4234-a06c-54c6f3d1daf1",
"metadata": {},
"outputs": [],
"source": [
"# it will be parsed from the fruit basket\n",
"# pick a fruit\n",
"# hang onto tree\n",
"# parse the string letter by using the grepFirstLetter\n",
"def insertLeaf(root,wordFruit):\n",
" #create new leaf \n",
" letter = grepFirstLetter(wordFruit)\n",
" #print(\"first letter of {} is : {} \".format(wordFruit, letter))\n",
" #creating a new node containing firstLetter and wordFruit\n",
" newleaf = letterLeaf(letter,wordFruit)\n",
" #print(\"test print attributes {} {}\".format(newleaf.letter, newleaf.wordFruit))\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (letter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (letter < y.letter):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 135,
"id": "dc2230e9-0831-4e3c-93b8-c96d20fd0525",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"here is a tree that's laying on the ground: \n",
"\n",
" z\n",
" zhe\n",
"\n",
" y\n",
" yuzu\n",
"\n",
" x\n",
" ximenia\n",
"\n",
"w\n",
"water chestnut\n",
"\n",
" v\n",
" vanilla\n",
"\n",
" u\n",
" ugli fruit\n",
"\n",
" t\n",
" tangor\n",
"\n",
" s\n",
" star fruit\n",
"\n",
" r\n",
" rambutan\n",
"\n",
" q\n",
" quandong\n",
"\n",
" p\n",
" persimmon\n",
"\n",
" o\n",
" olive\n",
"\n",
" n\n",
" nectarine\n",
"\n",
" m\n",
" mandarin\n",
"\n",
" l\n",
" lychee\n",
"\n",
" k\n",
" kiwi\n",
"\n",
" j\n",
" jujube\n",
"\n",
" h\n",
" hawthorne\n",
"\n",
" g\n",
" guava\n",
"\n",
" f\n",
" fig\n",
"\n",
" e\n",
" egg fruit\n",
"\n",
" d\n",
" durian\n",
"\n",
" c\n",
" currant\n",
"\n",
" b\n",
" blood orange\n",
"\n",
" a\n",
" apricot\n"
]
}
],
"source": [
"# same deal, insert everything in the list until it's empty \n",
"import random\n",
"\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_fruit = random.choice(fruit_list)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insertLeaf(root, random_fruit)\n",
"# remove that letter from list\n",
"fruit_list.remove(random_fruit)\n",
"#print(fruit_list)\n",
"len_list = (len(fruit_list))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_fruit = random.choice(fruit_list)\n",
" insertLeaf(root,random_fruit)\n",
" fruit_list.remove(random_fruit)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations\n"
]
},
{
"cell_type": "code",
"execution_count": 136,
"id": "6fc4208f-8088-476d-b20d-0f0ac0e85066",
"metadata": {},
"outputs": [],
"source": [
"# fruits in structured presetations:\n",
"# https://zhuanlan.zhihu.com/p/113457497\n",
"# https://www.wordmom.com/fruits/that-start-with-w"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7bd7553d-8ed4-436b-b4cf-99395a4f91b9",
"metadata": {},
"outputs": [],
"source": [
"# more fun stuff\n",
"# https://en.wikipedia.org/wiki/Flora_Sinensis\n"
]
},
{
"cell_type": "markdown",
"id": "5b11e6fc-0443-4373-8530-5f2b2f1b0aa7",
"metadata": {},
"source": [
"During a potluck dinner in Beijing Adel brought an dish made from pomegrante seeds. It was in December, the crowd was not used to the fruit salad dish. Adel was the only Iranian there. A talented cook as Adel was, the dish was barely touched. \n",
"Adel, I think you would agree with me that international potlucks are as bad as they can be. Let's hang the fruits high up - trees are good to store and access memories. For the pomegrantes seeds that I've missed that evening. "
]
}
],
"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
}

0
a_linked_list_tree.ipynb
Unescape Escape View File

383
a_longan_tree.ipynb
Unescape Escape View File

@ -0,0 +1,383 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "59b5e56e-137c-4c72-8832-3fb7e625fddc",
"metadata": {},
"source": [
"# a longan tree\n",
"# 龙眼树"
]
},
{
"cell_type": "markdown",
"id": "1d3d5765-21b5-4022-8fb6-995feadbd000",
"metadata": {},
"source": [
"## what is longan?\n",
"Dimocarpus longan, commonly known as the longan, is a tropical tree species that produces edible fruit. It is one of the better-known tropical members of the soapberry family Sapindaceae,to which the lychee and rambutan also belong. The fruit of the longan is similar to that of the lychee, but less aromatic in taste."
]
},
{
"cell_type": "markdown",
"id": "8bd7458b-bbb1-4977-9f78-a4f8f2e93985",
"metadata": {},
"source": [
"### a photo of a longan tree with fruits\n",
"from reddit post https://www.reddit.com/r/gardening/comments/8cfh6n/our_glorious_longan_tree/"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "39a00b5f-45ca-4356-ad0e-b2cef2593ef1",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<img src=\"images/longan_tree.jpg\" width=\"400\" height=\"400\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.display import Image\n",
"url_tree = \"images/longan_tree.jpg\"\n",
"Image(url= url_tree, width=400, height=400)"
]
},
{
"cell_type": "markdown",
"id": "547e4b39-856f-4374-a23a-b95917817749",
"metadata": {},
"source": [
"## what is the soapberry family Sapindaceae?\n",
"The Sapindaceae are a family of flowering plants in the order Sapindales known as the soapberry family. \n"
]
},
{
"cell_type": "markdown",
"id": "9a0050aa-eabb-4407-971e-abd89f9ddb17",
"metadata": {},
"source": [
"### why is knowing the soapberry family important for the longan tree"
]
},
{
"cell_type": "markdown",
"id": "68ba1fba-d0f0-4e6f-952b-07ae19262df8",
"metadata": {},
"source": [
"As we know the longan tree is one tree species under the soapberry family, we can track the other tree species relevant to the longan tree. The lychee tree, the rambutan tree, and the longan tree are closely related to each other. "
]
},
{
"cell_type": "markdown",
"id": "0af3e49f-f417-4779-afc8-9932be9539f5",
"metadata": {},
"source": [
"This is written in early spring, and longan fruits are harvested during the summer. In villages in Southern China, harvesting longan fruits \"摘龙眼\"is a fun summer activity. "
]
},
{
"cell_type": "markdown",
"id": "7ba8cd22-532f-424c-8c57-96990a8903fd",
"metadata": {},
"source": [
"Longan also means \"dragon eye\". The fruit is round, resembling an eyeball of a dragon. There is also the \"phoenix eye\"(凤眼),referring to eyes that has a long-ish shape and tilts upwards. "
]
},
{
"cell_type": "markdown",
"id": "3f133efd-1adf-40f0-acb6-24fbff03bebb",
"metadata": {},
"source": [
"In a gender binary context, suppose there is a pair of twins that's a boy and a girl. In Chinese such pair of twins is refered to as \"dragon and phoenix twin\"(龙凤胎)。Suppose the girl has the \"phonenix eyes\"(凤眼), then would the boy eat loads of \"dragon eyes\"(龙眼)?!\n",
"在性别二元对立的语境下，有一对龙凤胎，女孩有一双凤眼，那男孩岂不是有一双龙眼？！"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "23f11815-0327-4027-8e4a-6004595e9525",
"metadata": {},
"outputs": [],
"source": [
"eyes_l = [\"⊙\",\"ಠ\",\"ಡ\",\"⚆\",\n",
" \"✪\",\"◙\",\"*\",\"°\",\n",
" \"☉\",\"⚈\",\"๏\",\"◔\",\n",
" \"◉\",\"ʘ\",\"Θ\",\"❍\",\n",
" \"●\",\"ᓂ\",\"ᓀ\",\"•͈\",\n",
" ]"
]
},
{
"cell_type": "markdown",
"id": "e9181f99-311b-4788-bba1-3781b62dc7f8",
"metadata": {},
"source": [
"## dragon eyes of various affects\n",
"呆萌的龙眼，迟疑的龙眼，左顾右盼的龙眼，闪烁其辞的龙眼。\n",
"被踩扁的龙眼，爆了浆的龙眼，剥开皮的龙眼，被掏空的龙眼。"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "f74f4027-9305-4862-adb9-3bd46bae37ad",
"metadata": {},
"outputs": [],
"source": [
"# build a tree from eyes_l\n",
"# can try a binary tree structure\n",
"# however, a longan tree cannot be arbitrarily defined as using\n",
"# the bst structure\n",
"# are there other tree branching structures to try? "
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "35a275f8-71d4-4354-b019-befc9650c042",
"metadata": {},
"outputs": [],
"source": [
"# starting from a yard of trees: longan, lychee and rombutan "
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "fe8cc549-0ffe-4d55-afb3-a49605fca2c1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"soapberry forest\n",
"├── longan\n",
"├── lychee\n",
"└── rombutan\n"
]
}
],
"source": [
"from anytree import Node, RenderTree\n",
"# build tree\n",
"soapberryForest = Node(\"soapberry forest\")\n",
"longan = Node(\"longan\", parent=soapberryForest)\n",
"lychee = Node(\"lychee\", parent=soapberryForest)\n",
"rombutan = Node(\"rombutan\", parent=soapberryForest)\n",
"\n",
"# print tree\n",
"for pre, fill, node in RenderTree(soapberryForest):\n",
"\tprint(\"%s%s\" %(pre,node.name))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "a651378f-02e3-4da4-8510-3754af471cc2",
"metadata": {},
"outputs": [],
"source": [
"# bst tree template \n",
"\"\"\"Python3 program to demonstrate insert\n",
"operation in binary search tree \"\"\"\n",
"\n",
"# A Binary Tree Node\n",
"# Utility function to create a\n",
"# new tree node\n",
"class newNode:\n",
"\n",
" # Constructor to create a newNode\n",
" def __init__(self, data):\n",
" self.key= data\n",
" self.left = None\n",
" self.right = self.parent = None\n",
"\n",
"# A utility function to insert a new\n",
"# Node with given key in BST\n",
"def insert(root, key):\n",
"\n",
" # Create a new Node containing\n",
" # the new element\n",
" newnode = newNode(key)\n",
"\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (key < x.key):\n",
" x = x.left\n",
" else:\n",
" x = x.right\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newnode\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (key < y.key):\n",
" y.left = newnode\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.right = newnode\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"#Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" root = None\n",
" root = insert(root, \"longan tree\")\n",
" for eye in eyes_l:\n",
" insert(root,eye)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "ef3979c3-7da9-4bb3-a691-4a210da308cb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
" ❍\n",
"\n",
" ✪\n",
"\n",
" ⚈\n",
"\n",
" ⚆\n",
"\n",
" ☉\n",
"\n",
" ◙\n",
"\n",
" ◔\n",
"\n",
" ●\n",
"\n",
" ◉\n",
"\n",
" ⊙\n",
"\n",
" •͈\n",
"\n",
" ᓂ\n",
"\n",
" ᓀ\n",
"\n",
" ๏\n",
"\n",
" ಡ\n",
"\n",
" ಠ\n",
"\n",
" Θ\n",
"\n",
" ʘ\n",
"\n",
" °\n",
"\n",
"longan tree\n",
"\n",
" *\n"
]
}
],
"source": [
"COUNT = [10]\n",
"def print2DUtil(root, space) :\n",
"\n",
" # Base case\n",
" if (root == None) :\n",
" return\n",
"\n",
" # Increase distance between levels\n",
" space += COUNT[0]\n",
"\n",
" # Process right child first\n",
" print2DUtil(root.right, space)\n",
"\n",
" # Print current node after space\n",
" # count\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.key)\n",
"\n",
" # Process left child\n",
" print2DUtil(root.left, space)\n",
"\n",
"# Wrapper over print2DUtil()\n",
"def print2D(root) :\n",
" \n",
" # space=[0]\n",
" # Pass initial space count as 0\n",
" print2DUtil(root, 0)\n",
"\n",
"# Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" \n",
" print2D(root)"
]
},
{
"cell_type": "markdown",
"id": "d8d8b5fa-49cf-47e5-8c69-a0285b286030",
"metadata": {},
"source": [
"a pun, a poem, a puoem. "
]
}
],
"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
}

0
a_longan_tree.nbdata
Unescape Escape View File

314
a_morse_code_tree.ipynb
Unescape Escape View File

@ -0,0 +1,314 @@
{
"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
}

0
a_post_code_tree.ipynb
Unescape Escape View File

49
a_procedural_morse_code_tree.ipynb
Unescape Escape View File

@ -0,0 +1,49 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "23070ca4-55cc-4a58-97d5-cb2fcb9c30a2",
"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": "6ca5a800-4180-43bc-9a1c-ba260b9f207a",
"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
}

33
a_radio_tree.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "2b1fd5e7-4734-46ad-b57f-8c05acd86338",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

53
a_raspberry_orange_tree.ipynb
Unescape Escape View File

@ -0,0 +1,53 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "d620c21c-89d5-4b37-888f-79212671d7db",
"metadata": {},
"source": [
"# a raspberry orange tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "343265dc-49bd-4220-96aa-3ed2fbd1a54e",
"metadata": {},
"outputs": [],
"source": [
"# https://www.reddit.com/r/aldi/comments/kqxzuc/the_raspberry_oranges_are_wonderful/"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f519c19c-03f2-4332-be12-fd3beab81cb7",
"metadata": {},
"outputs": [],
"source": [
"# pigment is shared between the raspberry species and the raspberry orange species"
]
}
],
"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
}

33
a_reddit_tree.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "574ccf52-a1c4-46b4-b7cc-7cea29cc6ff5",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

194
a_sample_tree.ipynb
Unescape Escape View File

@ -0,0 +1,194 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "f9f2a93f-62ee-411a-a8dd-2a6745444c02",
"metadata": {},
"source": [
"# a sample tree, the starter program to begin all the trees with"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0e9adc4-5400-491d-a6bd-4ae93b4fbb38",
"metadata": {},
"outputs": [],
"source": [
"\"\"\"Python3 program to demonstrate insert\n",
"operation in binary search tree \"\"\"\n",
"\n",
"# A Binary Tree Node\n",
"# Utility function to create a\n",
"# new tree node\n",
"class newNode:\n",
"\n",
" # Constructor to create a newNode\n",
" def __init__(self, data):\n",
" self.key= data\n",
" self.left = None\n",
" self.right = self.parent = None\n",
"\n",
"# A utility function to insert a new\n",
"# Node with given key in BST\n",
"def insert(root, key):\n",
"\n",
" # Create a new Node containing\n",
" # the new element\n",
" newnode = newNode(key)\n",
"\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (key < x.key):\n",
" x = x.left\n",
" else:\n",
" x = x.right\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newnode\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (key < y.key):\n",
" y.left = newnode\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.right = newnode\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST\n",
"def Inorder(root) :\n",
"\n",
" if (root == None) :\n",
" return\n",
" else:\n",
" Inorder(root.left)\n",
" print( root.key, end = \" \" )\n",
" Inorder(root.right)\n",
"\n",
"#Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" root = None\n",
" root = insert(root, \"m\")\n",
" insert(root, \"n\")\n",
" insert(root, \"l\")\n",
" insert(root, \"p\")\n",
" insert(root, \"q\")\n",
" insert(root, \"a\")\n",
" insert(root, \"b\")\n",
"\n",
"\n",
" # Pr inorder traversal of the BST\n",
"\n",
"\n",
"# This code is contributed by\n",
"# SHUBHAMSINGH10"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "921f4017-3f1f-4085-8da8-cc850fbd4c6e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
" q\n",
"\n",
" p\n",
"\n",
" n\n",
"\n",
"m\n",
"\n",
" l\n",
"\n",
" b\n",
"\n",
" a\n"
]
}
],
"source": [
"# print binary tree in 2D copied from sample program\n",
"COUNT = [10]\n",
"def print2DUtil(root, space) :\n",
"\n",
" # Base case\n",
" if (root == None) :\n",
" return\n",
"\n",
" # Increase distance between levels\n",
" space += COUNT[0]\n",
"\n",
" # Process right child first\n",
" print2DUtil(root.right, space)\n",
"\n",
" # Print current node after space\n",
" # count\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.key)\n",
"\n",
" # Process left child\n",
" print2DUtil(root.left, space)\n",
"\n",
"# Wrapper over print2DUtil()\n",
"def print2D(root) :\n",
" \n",
" # space=[0]\n",
" # Pass initial space count as 0\n",
" print2DUtil(root, 0)\n",
"\n",
"# Driver Code\n",
"if __name__ == '__main__':\n",
"\n",
" \n",
" print2D(root)"
]
}
],
"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
}

33
a_tree_of_trees.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "c17f30da-2c18-4e79-9000-a4e1757d076c",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

416
a_tree_scraping_from_web.ipynb
Unescape Escape View File

@ -0,0 +1,416 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "9da34557-037a-436f-bbaa-d332057cbe18",
"metadata": {},
"source": [
"a tree extending to the web, pasted with images of the named fruit. the process is done by making a request to the web and scraping an image returned from the request. \n",
"\n",
"modified from the hanging tree program "
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "01acaa97-796a-4e34-9ee3-a46e71493d9d",
"metadata": {},
"outputs": [],
"source": [
"fruit_list = [\"apricot\",\"blood orange\",\"currant\",\"durian\",\"egg fruit\",\"fig\",\"guava\",\n",
" \"hawthorne\",\"jujube\",\"kiwi\",\"lychee\",\"mandarin\",\"nectarine\",\"olive\",\"persimmon\",\"quandong\",\"rambutan\",\"star fruit\",\n",
" \"tangor\",\"ugli fruit\",\"vanilla\",\"water chestnut\",\"ximenia\",\"yuzu\",\"zhe\"]\n",
"# additionally: longan yumberry sugarcane "
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "a827df76-4293-4c7f-9f65-7c9c3e4f6b4f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"https://media.geeksforgeeks.org/wp-content/cdn-uploads/write_ndi_20210312.svg\n",
"https://media.geeksforgeeks.org/wp-content/cdn-uploads/practice_ndi_20210312.svg\n",
"https://media.geeksforgeeks.org/wp-content/cdn-uploads/premium_ndi_20210312.svg\n",
"https://media.geeksforgeeks.org/wp-content/cdn-uploads/jobs_ndi_20210312.svg\n",
"https://media.geeksforgeeks.org/wp-content/cdn-uploads/20220228124519/Artboard-6-min.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/GunDetectionUsingPythonOpenCV/gundetectionusingpython20220310130800-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/HowtoPerformCRUDOperationsinFlutterApplicationusingMySQLDatabase/HowtoPerformCRUDOperationsinFlutterApplicationusingMySQLDatabase20220304112711.jpg\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/ImplementingSimpleandCustomAlertDialoginFlutterApplication/AlertDialoginFlutterApplication20220303121322-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/BuildaSimpleStopwatchApplicationinFlutter/BuildaSimpleStopwatchApplicationinFlutter20220302114511-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/MLTreatingCategoricalDataImplementationinPython/TreatingCategoricalDataImplementationinPython20220301102144-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/GettingStartedwithMaterialDesigninFlutter/MaterialDesigninFlutter20220228105528-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/HowtoBuildaToDoApplicationinFlutter/HowtoBuildaToDoApplicationinFlutter20220226163539-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/HowtoUseGoogleSigninWithFirebaseinFlutter/HowtoUseGoogleSigninWithFirebaseinFlutter20220225131450-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/ImplementingSwipetoUnlockFeatureinFlutter/HowtoImplementSwipetoUnlockFeatureinFlutterApplication20220224115856-small.png\n",
"https://videocdn.geeksforgeeks.org/geeksforgeeks/MachineLearningHandlingCategoricalData/MachineLearningHandlingCategoricalData20220223123041-small.png\n",
"https://media.geeksforgeeks.org/wp-content/post-ads-banner/2021-12-29-11-18-16-DSA_Ad_icon (1).png\n",
"https://media.geeksforgeeks.org/wp-content/post-ads-banner/2021-12-29-16-30-50-CIP_Icon.png\n",
"https://media.geeksforgeeks.org/wp-content/post-ads-banner/2021-12-29-11-27-51-SD Icon.png\n",
"\n"
]
}
],
"source": [
"# for each word in list, make a request to search that keyword in a search engine\n",
"import requests\n",
"from bs4 import BeautifulSoup\n",
"\n",
"def getdata(url):\n",
" r = requests.get(url)\n",
" return r.text\n",
"\n",
"htmldata = getdata(\"https://www.geeksforgeeks.org/\")\n",
"soup = BeautifulSoup(htmldata, 'html.parser')\n",
"for item in soup.find_all('img'):\n",
" print(item['src'])\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "df31e89e-7a79-41f7-b5a0-bbca56374e41",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"https://duckduckgo.com/?q=apple&atb=v315-5&iar=images&iax=images&ia=images\n"
]
}
],
"source": [
"# Import the beautifulsoup\n",
"# and request libraries of python.\n",
"import requests\n",
"import bs4\n",
"\n",
"# Make two strings with default google search URL\n",
"# 'https://google.com/search?q=' and\n",
"# our customized search keyword.\n",
"# Concatenate them\n",
"text= \"apple\"\n",
"url = 'https://duckduckgo.com/?q='+ text + '&atb=v315-5&iar=images&iax=images&ia=images' \n",
"print(url)\n",
"#url = 'https://duckduckgo.com/?q=apple&atb=v315-5&iar=images&iax=images&ia=images'\n",
"# Fetch the URL data using requests.get(url),\n",
"# store it in a variable, request_result.\n",
"#request_result=requests.get( url )\n",
"\n",
"# Creating soup from the fetched request\n",
"#soup = bs4.BeautifulSoup(request_result.text,\n",
" # \"html.parser\")\n",
"#print(soup)\n"
]
},
{
"cell_type": "code",
"execution_count": 130,
"id": "08ab8673-9b5c-4bd0-9fac-72796e831b94",
"metadata": {},
"outputs": [],
"source": [
"# build the fruit motley tree with extra utilities than the letter tree"
]
},
{
"cell_type": "code",
"execution_count": 131,
"id": "9c7187e4-0c49-4908-a169-775e6e475f94",
"metadata": {},
"outputs": [],
"source": [
"class letterLeaf:\n",
" def __init__(self,letter,wordFruit):\n",
" self.leftAlphabet = None\n",
" self.rightAlphabet = None\n",
" self.letter = letter\n",
" # try using a list structure to contain the words in this node? \n",
" self.wordFruit = wordFruit"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "11dbf280-6c61-4020-bfe7-e85a723697db",
"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.rightAlphabet, space)\n",
" print()\n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" print(root.letter)\n",
" \n",
" for i in range(COUNT[0], space):\n",
" print(end = \" \")\n",
" #print(root.letter) \n",
" print(root.wordFruit)\n",
" # Process left child\n",
" print2DUtil_flat(root.leftAlphabet, 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": 133,
"id": "d0bcd376-491e-48e9-8bd9-e10d91346d7f",
"metadata": {},
"outputs": [],
"source": [
"#the input was for an interactive version like text input used by wang, save for later \n",
"def grepFirstLetter(word):\n",
" #word = input()\n",
" firstLetter = word[0]\n",
" return firstLetter\n",
" #print(\"the letter starts with : {}, and will be inserted under the {} leaf\".format(firstLetter, firstLetter))"
]
},
{
"cell_type": "code",
"execution_count": 134,
"id": "7a12a00f-f7b0-4234-a06c-54c6f3d1daf1",
"metadata": {},
"outputs": [],
"source": [
"# it will be parsed from the fruit basket\n",
"# pick a fruit\n",
"# hang onto tree\n",
"# parse the string letter by using the grepFirstLetter\n",
"def insertLeaf(root,wordFruit):\n",
" #create new leaf \n",
" letter = grepFirstLetter(wordFruit)\n",
" #print(\"first letter of {} is : {} \".format(wordFruit, letter))\n",
" #creating a new node containing firstLetter and wordFruit\n",
" newleaf = letterLeaf(letter,wordFruit)\n",
" #print(\"test print attributes {} {}\".format(newleaf.letter, newleaf.wordFruit))\n",
" # python pointer implementation\n",
" # a root pointer \n",
" x = root\n",
" # pointer y maintains the trailing\n",
" # pointer of x\n",
" # Pointer to start traversing from root\n",
" # and traverses downward path to search\n",
" # where the new node to be inserted\n",
" x = root\n",
"\n",
" # Pointer y maintains the trailing\n",
" # pointer of x\n",
" y = None\n",
"\n",
" while (x != None):\n",
" y = x\n",
" if (letter < x.letter):\n",
" x = x.leftAlphabet\n",
" else:\n",
" x = x.rightAlphabet\n",
" \n",
" # If the root is None i.e the tree is\n",
" # empty. The new node is the root node\n",
" if (y == None):\n",
" y = newleaf\n",
"\n",
" # If the new key is less then the leaf node key\n",
" # Assign the new node to be its left child\n",
" elif (letter < y.letter):\n",
" y.leftAlphabet = newleaf\n",
"\n",
" # else assign the new node its\n",
" # right child\n",
" else:\n",
" y.rightAlphabet = newleaf\n",
"\n",
" # Returns the pointer where the\n",
" # new node is inserted\n",
" return y\n",
"\n",
"\n",
"# A utility function to do inorder\n",
"# traversal of BST"
]
},
{
"cell_type": "code",
"execution_count": 135,
"id": "dc2230e9-0831-4e3c-93b8-c96d20fd0525",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"here is a tree that's laying on the ground: \n",
"\n",
" z\n",
" zhe\n",
"\n",
" y\n",
" yuzu\n",
"\n",
" x\n",
" ximenia\n",
"\n",
"w\n",
"water chestnut\n",
"\n",
" v\n",
" vanilla\n",
"\n",
" u\n",
" ugli fruit\n",
"\n",
" t\n",
" tangor\n",
"\n",
" s\n",
" star fruit\n",
"\n",
" r\n",
" rambutan\n",
"\n",
" q\n",
" quandong\n",
"\n",
" p\n",
" persimmon\n",
"\n",
" o\n",
" olive\n",
"\n",
" n\n",
" nectarine\n",
"\n",
" m\n",
" mandarin\n",
"\n",
" l\n",
" lychee\n",
"\n",
" k\n",
" kiwi\n",
"\n",
" j\n",
" jujube\n",
"\n",
" h\n",
" hawthorne\n",
"\n",
" g\n",
" guava\n",
"\n",
" f\n",
" fig\n",
"\n",
" e\n",
" egg fruit\n",
"\n",
" d\n",
" durian\n",
"\n",
" c\n",
" currant\n",
"\n",
" b\n",
" blood orange\n",
"\n",
" a\n",
" apricot\n"
]
}
],
"source": [
"# same deal, insert everything in the list until it's empty \n",
"import random\n",
"\n",
"root = None\n",
"# pick a random letter in the alphabet\n",
"random_fruit = random.choice(fruit_list)\n",
"#print(random_letter)\n",
"#insert it into the tree, insert the first one \n",
"root = insertLeaf(root, random_fruit)\n",
"# remove that letter from list\n",
"fruit_list.remove(random_fruit)\n",
"#print(fruit_list)\n",
"len_list = (len(fruit_list))\n",
"#print(len_list)\n",
"while len_list > 0:\n",
" random_fruit = random.choice(fruit_list)\n",
" insertLeaf(root,random_fruit)\n",
" fruit_list.remove(random_fruit)\n",
" #print(\"inserting and removing letter {} \".format(random_letter))\n",
" len_list -= 1\n",
"# keep inserting until the list is empty \n",
"# print tree \n",
"print2D(root)\n",
"# can try multiple times for different tree configurations\n"
]
},
{
"cell_type": "code",
"execution_count": 136,
"id": "6fc4208f-8088-476d-b20d-0f0ac0e85066",
"metadata": {},
"outputs": [],
"source": [
"# fruits in structured presetations:\n",
"# https://zhuanlan.zhihu.com/p/113457497\n",
"# https://www.wordmom.com/fruits/that-start-with-w"
]
},
{
"cell_type": "markdown",
"id": "5b11e6fc-0443-4373-8530-5f2b2f1b0aa7",
"metadata": {},
"source": [
"During a potluck dinner in Beijing Adel brought an dish made from pomegrante seeds. It was in December, the crowd was not used to the fruit salad dish. Adel was the only Iranian there. A talented cook as Adel was, the dish was barely touched. \n",
"Adel, I think you would agree with me that international potlucks are as bad as they can be. Let's hang the fruits high up - trees are good to store and access memories. For the pomegrantes seeds that I've missed that evening. "
]
}
],
"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
}

49
a_trident_tree.ipynb
Unescape Escape View File

@ -0,0 +1,49 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "1cb5571e-af37-47eb-ba2d-5c10c87fbb9e",
"metadata": {},
"outputs": [],
"source": [
"class tridentLeaf:\n",
" def __init__(self,something,somethingelse):\n",
" self.leftProng = None\n",
" self.middleProng = None\n",
" self.rightProng = None\n",
" self.something = something\n",
" self.somethingelse = somethingelse"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6c797c5b-e7e0-432f-9a85-27e7c6e1bdc9",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

46
a_trimmed_tree.ipynb
Unescape Escape View File

@ -0,0 +1,46 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "baf7d8e8-1cc2-4f18-b5a7-ce5bb7c45bef",
"metadata": {},
"source": [
"# a cutting tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b6057018-bdeb-429a-8e66-130419251ef9",
"metadata": {},
"outputs": [],
"source": [
"# during an evening walk after the marshall fire, i saw a local\n",
"# tree trimming company handling trees that were either entirely \n",
"# fallen off or were dangling. the trees needed to be removed as\n",
"# they may be of hazard for the pedestrians and the road. "
]
}
],
"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
}

33
a_willow_tree.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "cd29e163-6a53-4f3a-a6c7-d6489f85f405",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

0
a_wood_pecking_tree.ipynb
Unescape Escape View File

40
about.md
Unescape Escape View File

@ -0,0 +1,40 @@
# A Letter Tree With Hanging Fruits
## What
"A Letter Tree With Hanging Fruits" is a symbolic tree that grows 26 different fruits, with each name starting with a letter from the English alphabet. The computer program uses the tree structure, an abstract data structure used to store, retrieve and represent hierarchical information. The information, in this case, a list containing the words of the fruits, is processed hierarchically by recursion, an algorithmic procedure that constantly calls upon itself until an exit condition is met.
## How
There are two recursive procedures applied in the program, one to build the tree, and the other to print the tree. Between line 45 and 67, the insertLeaf function recursively traverse the tree, looking for a suitable place to insert the word of the fruit as predefined by a hierarchical rule. The hierarchical rule used in the program simply compares the order of the word's first letter. Words starting with "bigger" letters will be placed on the right side, and vice versa. Between line 15 and 35, the print2DUtil_flat function visually renders the tree's levelled hierarchies. The function starts in the tree's furthest right. For words placed in "lower" levels, more empty spaces are printed, and vice versa.
## Why
The program is intended to be a simple yet playful reflection on the convergence of mathematics, language, and symbol. While the program's association with these subjects may immediately sound daunting, as the audience pays inquisitive attention to how the program's outputs are being rendered interactively in the console, they are witnessing a tangible interplay of the subjects.
Originally, the program was written as a response to a piece of archival information found on the subject of Chinese text processing. Due to the incompatibilities resulted from organizational differences between Chinese as an ideographic writing system and alphanumeric writing systems, such as English, advanced Chinese text processing technologies were near scarce in the early history of computing. Computationally, it was expensive and hence incompatible to accommodate a corpus of Chinese glyphs in the systems of hardware and software first intended to process alphanumeric writing systems. Here, the concept of incompatibility derives from singularly determined frameworks that are efficient and monolingual. Outside the singularly determined frameworks, there is a rich ecology of artifacts, approaches, and interpretations on Chinese text processing that each embody uniqueness and idiosyncrasy.
Take the archival information as an example. In the early 1990s, the Chinese writer and programmer Wang Xiaobo was crafting a Chinese text editor. Wang used a binary tree structure to implement a feature to store customized word combinations.
Hierarchy
Dynamic programming
Self generation of recursion
Self modification
permutation
Recursion in computational linguistics
dabai dabaicai dabaiyutianxia
The attention to science and mathematics permeates his writing.
hierarchical rule
camel case and snake case
Tree of life in (esoteric) mystery spiritualism trees
typographical qualities
empty spaces
vacancies
## Ring
"I Like Mathematics And Tight Pants"
"https://sfpc.study/sessions/summer-22/learning-to-love-math"
Qianxun Chen's seedlings
Metamagical thema "structure and strangeness"
<!-- will a handwritten dynamic gif like taeyoon choi's be helpful for the thing?-- >

33
an_evolutionary_tree.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "65ca64ef-5513-45b8-8e06-7538efd2b6c1",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

43
an_html_tree.ipynb
Unescape Escape View File

@ -0,0 +1,43 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "2691ed6e-f79f-4b86-abee-e8453d20c528",
"metadata": {},
"source": [
"# an html tree"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d8ba1dd7-1f42-4eb0-84a2-0bee2fc96f49",
"metadata": {},
"outputs": [],
"source": [
"#"
]
}
],
"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
}

33
an_nlp_tree.ipynb
Unescape Escape View File

@ -0,0 +1,33 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"id": "8ffb184c-7941-44a6-84c4-422ba9deac43",
"metadata": {},
"outputs": [],
"source": []
}
],
"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
}

BIN
computer_folder_tree.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 31 KiB

BIN
computer_lib_tree.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 220 KiB

BIN
docTree.jpg
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 55 KiB

BIN
fig_18_1.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 445 KiB

BIN
fig_7_2_a.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 430 KiB

BIN
fig_7_2_b.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 434 KiB

BIN
i_ching_tree.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 509 KiB

BIN
images/longan_tree.jpg
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.6 MiB

BIN
images/pic_tree_fruit_img/apricot.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 39 KiB

BIN
images/pic_tree_fruit_img/blood_orange.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.9 KiB

BIN
images/pic_tree_fruit_img/currant.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 52 KiB

BIN
images/pic_tree_fruit_img/durian.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 93 KiB

BIN
images/pic_tree_fruit_img/egg_fruit.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 418 KiB

BIN
images/pic_tree_fruit_img/fig.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 320 KiB

BIN
images/pic_tree_fruit_img/guava.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 93 KiB

BIN
images/pic_tree_fruit_img/hawthorne.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 196 KiB

BIN
images/pic_tree_fruit_img/jujube.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 186 KiB

BIN
images/pic_tree_fruit_img/kiwi.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 194 KiB

BIN
images/pic_tree_fruit_img/lychee.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 133 KiB

BIN
images/pic_tree_fruit_img/mandarin.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 30 KiB

BIN
images/pic_tree_fruit_img/nectarine.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 94 KiB

BIN
images/pic_tree_fruit_img/olive.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 134 KiB

BIN
images/pic_tree_fruit_img/persimmon.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 100 KiB

BIN
images/pic_tree_fruit_img/quandong.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 17 KiB

BIN
images/pic_tree_fruit_img/rambutan.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 214 KiB

BIN
images/pic_tree_fruit_img/star_fruit.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 204 KiB

BIN
images/pic_tree_fruit_img/tangor.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 57 KiB

BIN
images/pic_tree_fruit_img/ugli_fruit.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 15 KiB

BIN
images/pic_tree_fruit_img/vanilla.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 136 KiB

BIN
images/pic_tree_fruit_img/vanilla_backup.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 87 KiB

BIN
images/pic_tree_fruit_img/water_chestnut.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 70 KiB

BIN
images/pic_tree_fruit_img/ximenia.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 84 KiB

BIN
images/pic_tree_fruit_img/yuzu.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 185 KiB

BIN
images/pic_tree_fruit_img/zhe.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
images/屏幕快照 2021-04-22 下午1.09.08.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 96 KiB

BIN
images/屏幕快照 2021-04-22 下午1.09.32.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 280 KiB

BIN
images/屏幕快照 2021-04-22 下午1.13.46.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 244 KiB

BIN
images/屏幕快照 2021-04-22 下午1.17.47.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 388 KiB

BIN
images/屏幕快照 2021-04-22 下午3.41.30.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 205 KiB

BIN
images/屏幕快照 2021-04-22 下午3.41.50.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 107 KiB

BIN
pic_tree_fruit_img/apricot.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 39 KiB

BIN
pic_tree_fruit_img/blood_orange.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.9 KiB

BIN
pic_tree_fruit_img/currant.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 52 KiB

BIN
pic_tree_fruit_img/durian.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 93 KiB

BIN
pic_tree_fruit_img/egg_fruit.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 418 KiB

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save