File size: 87,019 Bytes
d50e007 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 | {"topic": "Hello World", "language": "python", "code": "print(\"Hello, World!\")", "note": ""}
{"topic": "Hello World", "language": "nim", "code": "echo \"Hello, World!\"", "note": ""}
{"topic": "Bien so va kieu du lieu", "language": "python", "code": "x = 10\ny = 3.14\nname = \"Python\"\nprint(x, y, name)", "note": ""}
{"topic": "Bien so va kieu du lieu", "language": "nim", "code": "var x: int = 10\nvar y: float = 3.14\nvar name: string = \"Nim\"\necho x, \" \", y, \" \", name", "note": ""}
{"topic": "Vong lap for", "language": "python", "code": "for i in range(5):\n print(i)", "note": ""}
{"topic": "Vong lap for", "language": "nim", "code": "for i in 0..<5:\n echo i", "note": ""}
{"topic": "Vong lap while", "language": "python", "code": "i = 0\nwhile i < 5:\n print(i)\n i += 1", "note": ""}
{"topic": "Vong lap while", "language": "nim", "code": "var i = 0\nwhile i < 5:\n echo i\n inc i", "note": ""}
{"topic": "Cau lenh if-else", "language": "python", "code": "x = 10\nif x > 5:\n print(\"lon hon 5\")\nelse:\n print(\"nho hon hoac bang 5\")", "note": ""}
{"topic": "Cau lenh if-else", "language": "nim", "code": "let x = 10\nif x > 5:\n echo \"lon hon 5\"\nelse:\n echo \"nho hon hoac bang 5\"", "note": ""}
{"topic": "Ham co ban", "language": "python", "code": "def add(a, b):\n return a + b\n\nprint(add(3, 4))", "note": ""}
{"topic": "Ham co ban", "language": "nim", "code": "proc add(a, b: int): int =\n return a + b\n\necho add(3, 4)", "note": ""}
{"topic": "De quy - tinh giai thua", "language": "python", "code": "def factorial(n):\n if n <= 1:\n return 1\n return n * factorial(n - 1)\n\nprint(factorial(5))", "note": ""}
{"topic": "De quy - tinh giai thua", "language": "nim", "code": "proc factorial(n: int): int =\n if n <= 1: return 1\n return n * factorial(n - 1)\n\necho factorial(5)", "note": ""}
{"topic": "Fibonacci", "language": "python", "code": "def fib(n):\n if n <= 1:\n return n\n return fib(n - 1) + fib(n - 2)\n\nfor i in range(11):\n print(fib(i))", "note": ""}
{"topic": "Fibonacci", "language": "nim", "code": "proc fib(n: int): int =\n if n <= 1: return n\n return fib(n - 1) + fib(n - 2)\n\nfor i in 0..10:\n echo fib(i)", "note": ""}
{"topic": "Danh sach (list/array)", "language": "python", "code": "arr = [1, 2, 3, 4, 5]\nfor x in arr:\n print(x)", "note": ""}
{"topic": "Danh sach (list/array)", "language": "nim", "code": "var arr = @[1, 2, 3, 4, 5]\nfor x in arr:\n echo x", "note": ""}
{"topic": "Dictionary/Table (key-value)", "language": "python", "code": "d = {\"a\": 1, \"b\": 2}\nprint(d[\"a\"])", "note": ""}
{"topic": "Dictionary/Table (key-value)", "language": "nim", "code": "import tables\nvar t = {\"a\": 1, \"b\": 2}.toTable\necho t[\"a\"]", "note": ""}
{"topic": "Tap hop (set)", "language": "python", "code": "s = {1, 2, 3}\nprint(s)", "note": ""}
{"topic": "Tap hop (set)", "language": "nim", "code": "var s = {1, 2, 3}\necho s", "note": ""}
{"topic": "Tuple", "language": "python", "code": "t = (1, \"hello\")\nprint(t[0], t[1])", "note": ""}
{"topic": "Tuple", "language": "nim", "code": "let t = (1, \"hello\")\necho t[0], \" \", t[1]", "note": ""}
{"topic": "Thao tac chuoi (string)", "language": "python", "code": "s = \"Hello, Python!\"\nprint(s.upper())\nprint(len(s))", "note": ""}
{"topic": "Thao tac chuoi (string)", "language": "nim", "code": "import std/strutils\nlet s = \"Hello, Nim!\"\necho s.toUpperAscii()\necho s.len", "note": ""}
{"topic": "Doc/ghi file", "language": "python", "code": "with open(\"test.txt\", \"w\") as f:\n f.write(\"Hello file\\n\")\n\nwith open(\"test.txt\", \"r\") as f:\n print(f.read())", "note": ""}
{"topic": "Doc/ghi file", "language": "nim", "code": "let f = open(\"test.txt\", fmWrite)\nf.writeLine(\"Hello file\")\nf.close()\n\nlet content = readFile(\"test.txt\")\necho content", "note": ""}
{"topic": "Xu ly loi (exception)", "language": "python", "code": "try:\n raise ValueError(\"loi\")\nexcept ValueError as e:\n print(\"Bat loi:\", e)", "note": ""}
{"topic": "Xu ly loi (exception)", "language": "nim", "code": "try:\n raise newException(ValueError, \"loi\")\nexcept ValueError as e:\n echo \"Bat loi: \", e.msg", "note": ""}
{"topic": "Class/Object (OOP)", "language": "python", "code": "class Animal:\n def __init__(self, name):\n self.name = name\n\n def speak(self):\n print(f\"{self.name} keu\")\n\na = Animal(\"Cho\")\na.speak()", "note": ""}
{"topic": "Class/Object (OOP)", "language": "nim", "code": "type\n Animal = object\n name: string\n\nproc speak(a: Animal) =\n echo a.name, \" keu\"\n\nlet a = Animal(name: \"Cho\")\na.speak()", "note": ""}
{"topic": "Ke thua (inheritance)", "language": "python", "code": "class Animal:\n def __init__(self, name):\n self.name = name\n\n def speak(self):\n print(\"Dong vat keu\")\n\nclass Dog(Animal):\n def speak(self):\n print(f\"{self.name} sua\")\n\nd = Dog(\"Rex\")\nd.speak()", "note": ""}
{"topic": "Ke thua (inheritance)", "language": "nim", "code": "type\n Animal = object of RootObj\n name: string\n Dog = object of Animal\n\nmethod speak(a: Animal) {.base.} =\n echo \"Dong vat keu\"\n\nmethod speak(d: Dog) =\n echo d.name, \" sua\"\n\nvar d = Dog(name: \"Rex\")\nspeak(d)", "note": ""}
{"topic": "Sap xep bubble sort", "language": "python", "code": "def bubble_sort(arr):\n n = len(arr)\n for i in range(n):\n for j in range(n - i - 1):\n if arr[j] > arr[j + 1]:\n arr[j], arr[j + 1] = arr[j + 1], arr[j]\n return arr\n\nprint(bubble_sort([5, 2, 8, 1, 9]))", "note": ""}
{"topic": "Sap xep bubble sort", "language": "nim", "code": "proc bubbleSort(arr: var seq[int]) =\n for i in 0..<arr.len:\n for j in 0..<arr.len - i - 1:\n if arr[j] > arr[j + 1]:\n swap(arr[j], arr[j + 1])\n\nvar arr = @[5, 2, 8, 1, 9]\nbubbleSort(arr)\necho arr", "note": ""}
{"topic": "Sap xep quick sort", "language": "python", "code": "def quick_sort(arr):\n if len(arr) <= 1:\n return arr\n pivot = arr[len(arr) // 2]\n left = [x for x in arr if x < pivot]\n mid = [x for x in arr if x == pivot]\n right = [x for x in arr if x > pivot]\n return quick_sort(left) + mid + quick_sort(right)\n\nprint(quick_sort([10, 7, 8, 9, 1, 5]))", "note": ""}
{"topic": "Sap xep quick sort", "language": "nim", "code": "proc quickSort(arr: var seq[int], low, high: int) =\n if low < high:\n let pivot = arr[high]\n var i = low - 1\n for j in low..<high:\n if arr[j] < pivot:\n inc i\n swap(arr[i], arr[j])\n swap(arr[i + 1], arr[high])\n let p = i + 1\n quickSort(arr, low, p - 1)\n quickSort(arr, p + 1, high)\n\nvar arr = @[10, 7, 8, 9, 1, 5]\nquickSort(arr, 0, arr.len - 1)\necho arr", "note": ""}
{"topic": "Tim kiem nhi phan (binary search)", "language": "python", "code": "def binary_search(arr, target):\n low, high = 0, len(arr) - 1\n while low <= high:\n mid = (low + high) // 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n low = mid + 1\n else:\n high = mid - 1\n return -1\n\nprint(binary_search([1, 3, 5, 7, 9, 11], 7))", "note": ""}
{"topic": "Tim kiem nhi phan (binary search)", "language": "nim", "code": "proc binarySearch(arr: seq[int], target: int): int =\n var low = 0\n var high = arr.len - 1\n while low <= high:\n let mid = (low + high) div 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n low = mid + 1\n else:\n high = mid - 1\n return -1\n\nlet arr = @[1, 3, 5, 7, 9, 11]\necho binarySearch(arr, 7)", "note": ""}
{"topic": "Ham bac cao (map/filter)", "language": "python", "code": "nums = [1, 2, 3, 4, 5]\ndoubled = list(map(lambda x: x * 2, nums))\nevens = list(filter(lambda x: x % 2 == 0, nums))\nprint(doubled)\nprint(evens)", "note": ""}
{"topic": "Ham bac cao (map/filter)", "language": "nim", "code": "import std/sequtils\nlet nums = @[1, 2, 3, 4, 5]\nlet doubled = nums.map(proc(x: int): int = x * 2)\nlet evens = nums.filter(proc(x: int): bool = x mod 2 == 0)\necho doubled\necho evens", "note": ""}
{"topic": "List/seq comprehension", "language": "python", "code": "squares = [x * x for x in range(1, 6)]\nprint(squares)", "note": ""}
{"topic": "List/seq comprehension", "language": "nim", "code": "import std/sugar\nlet squares = collect(newSeq):\n for x in 1..5:\n x * x\necho squares", "note": ""}
{"topic": "Ham lambda", "language": "python", "code": "add = lambda a, b: a + b\nprint(add(3, 4))", "note": ""}
{"topic": "Ham lambda", "language": "nim", "code": "let add = proc(a, b: int): int = a + b\necho add(3, 4)", "note": ""}
{"topic": "Module/import co ban", "language": "python", "code": "import math\n\nprint(math.sqrt(16))\nprint(math.pow(2, 10))", "note": ""}
{"topic": "Module/import co ban", "language": "nim", "code": "import std/math\n\necho sqrt(16.0)\necho pow(2.0, 10.0)", "note": ""}
{"topic": "Kiem tra so nguyen to", "language": "python", "code": "def is_prime(n):\n if n < 2:\n return False\n for i in range(2, n):\n if n % i == 0:\n return False\n return True\n\nfor i in range(2, 21):\n if is_prime(i):\n print(i)", "note": ""}
{"topic": "Kiem tra so nguyen to", "language": "nim", "code": "proc isPrime(n: int): bool =\n if n < 2: return false\n for i in 2..<n:\n if n mod i == 0:\n return false\n return true\n\nfor i in 2..20:\n if isPrime(i):\n echo i", "note": ""}
{"topic": "Tinh UCLN (GCD)", "language": "python", "code": "def gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\nprint(gcd(48, 18))", "note": ""}
{"topic": "Tinh UCLN (GCD)", "language": "nim", "code": "proc gcd(a, b: int): int =\n var a = a\n var b = b\n while b != 0:\n let t = b\n b = a mod b\n a = t\n return a\n\necho gcd(48, 18)", "note": ""}
{"topic": "Doi cho hai bien (swap)", "language": "python", "code": "a, b = 5, 10\na, b = b, a\nprint(a, b)", "note": ""}
{"topic": "Doi cho hai bien (swap)", "language": "nim", "code": "var a = 5\nvar b = 10\nswap(a, b)\necho a, \" \", b", "note": ""}
{"topic": "Doc du lieu tu ban phim", "language": "python", "code": "name = input(\"Nhap ten cua ban: \")\nprint(f\"Xin chao, {name}!\")", "note": ""}
{"topic": "Doc du lieu tu ban phim", "language": "nim", "code": "stdout.write(\"Nhap ten cua ban: \")\nlet name = readLine(stdin)\necho \"Xin chao, \", name, \"!\"", "note": ""}
{"topic": "Xu ly nhieu loai ngoai le", "language": "python", "code": "try:\n x = int(\"abc\")\nexcept ValueError:\n print(\"Khong the chuyen doi chuoi thanh so\")\nfinally:\n print(\"Ket thuc xu ly\")", "note": ""}
{"topic": "Xu ly nhieu loai ngoai le", "language": "nim", "code": "try:\n let x = parseInt(\"abc\")\nexcept ValueError:\n echo \"Khong the chuyen doi chuoi thanh so\"\nfinally:\n echo \"Ket thuc xu ly\"", "note": ""}
{"topic": "Doc file theo tung dong", "language": "python", "code": "with open(\"test.txt\", \"r\") as f:\n for line in f:\n print(line.strip())", "note": ""}
{"topic": "Doc file theo tung dong", "language": "nim", "code": "for line in lines(\"test.txt\"):\n echo line", "note": ""}
{"topic": "Ngan xep (Stack)", "language": "python", "code": "stack = []\nstack.append(1)\nstack.append(2)\nstack.append(3)\nprint(stack.pop())\nprint(stack)", "note": ""}
{"topic": "Ngan xep (Stack)", "language": "nim", "code": "var stack: seq[int] = @[]\nstack.add(1)\nstack.add(2)\nstack.add(3)\necho stack.pop()\necho stack", "note": ""}
{"topic": "Hang doi (Queue)", "language": "python", "code": "from collections import deque\n\nqueue = deque()\nqueue.append(1)\nqueue.append(2)\nqueue.append(3)\nprint(queue.popleft())\nprint(queue)", "note": ""}
{"topic": "Hang doi (Queue)", "language": "nim", "code": "import std/deques\n\nvar queue = initDeque[int]()\nqueue.addLast(1)\nqueue.addLast(2)\nqueue.addLast(3)\necho queue.popFirst()\necho queue", "note": ""}
{"topic": "Danh sach lien ket don (Singly Linked List)", "language": "python", "code": "class Node:\n def __init__(self, value):\n self.value = value\n self.next = None\n\nclass LinkedList:\n def __init__(self):\n self.head = None\n\n def append(self, value):\n node = Node(value)\n if not self.head:\n self.head = node\n return\n cur = self.head\n while cur.next:\n cur = cur.next\n cur.next = node\n\n def print_list(self):\n cur = self.head\n while cur:\n print(cur.value, end=\" \")\n cur = cur.next\n print()\n\nll = LinkedList()\nll.append(1)\nll.append(2)\nll.append(3)\nll.print_list()", "note": ""}
{"topic": "Danh sach lien ket don (Singly Linked List)", "language": "nim", "code": "type\n Node = ref object\n value: int\n next: Node\n\n LinkedList = ref object\n head: Node\n\nproc append(l: LinkedList, value: int) =\n let node = Node(value: value)\n if l.head == nil:\n l.head = node\n return\n var cur = l.head\n while cur.next != nil:\n cur = cur.next\n cur.next = node\n\nproc printList(l: LinkedList) =\n var cur = l.head\n while cur != nil:\n stdout.write(cur.value, \" \")\n cur = cur.next\n echo \"\"\n\nvar ll = LinkedList()\nll.append(1)\nll.append(2)\nll.append(3)\nll.printList()", "note": ""}
{"topic": "Cay nhi phan tim kiem (BST) - chen node", "language": "python", "code": "class Node:\n def __init__(self, value):\n self.value = value\n self.left = None\n self.right = None\n\ndef insert(root, value):\n if root is None:\n return Node(value)\n if value < root.value:\n root.left = insert(root.left, value)\n else:\n root.right = insert(root.right, value)\n return root\n\nroot = None\nfor v in [5, 3, 8, 1, 4]:\n root = insert(root, v)", "note": ""}
{"topic": "Cay nhi phan tim kiem (BST) - chen node", "language": "nim", "code": "type\n Node = ref object\n value: int\n left, right: Node\n\nproc insert(root: Node, value: int): Node =\n if root == nil:\n return Node(value: value)\n if value < root.value:\n root.left = insert(root.left, value)\n else:\n root.right = insert(root.right, value)\n return root\n\nvar root: Node = nil\nfor v in [5, 3, 8, 1, 4]:\n root = insert(root, v)", "note": ""}
{"topic": "Duyet cay theo thu tu (Inorder traversal)", "language": "python", "code": "def inorder(root, result):\n if root is None:\n return\n inorder(root.left, result)\n result.append(root.value)\n inorder(root.right, result)\n return result\n\nresult = inorder(root, [])\nprint(result)", "note": ""}
{"topic": "Duyet cay theo thu tu (Inorder traversal)", "language": "nim", "code": "proc inorder(root: Node, res: var seq[int]) =\n if root == nil:\n return\n inorder(root.left, res)\n res.add(root.value)\n inorder(root.right, res)\n\nvar res: seq[int] = @[]\ninorder(root, res)\necho res", "note": ""}
{"topic": "BFS tren do thi (Breadth-First Search)", "language": "python", "code": "from collections import deque\n\ndef bfs(graph, start):\n visited = {start}\n queue = deque([start])\n order = []\n while queue:\n node = queue.popleft()\n order.append(node)\n for neighbor in graph[node]:\n if neighbor not in visited:\n visited.add(neighbor)\n queue.append(neighbor)\n return order\n\ngraph = {1: [2, 3], 2: [4], 3: [4], 4: []}\nprint(bfs(graph, 1))", "note": ""}
{"topic": "BFS tren do thi (Breadth-First Search)", "language": "nim", "code": "import std/[tables, sets, deques]\n\nproc bfs(graph: Table[int, seq[int]], start: int): seq[int] =\n var visited = initHashSet[int]()\n visited.incl(start)\n var queue = initDeque[int]()\n queue.addLast(start)\n var order: seq[int] = @[]\n while queue.len > 0:\n let node = queue.popFirst()\n order.add(node)\n for neighbor in graph[node]:\n if neighbor notin visited:\n visited.incl(neighbor)\n queue.addLast(neighbor)\n return order\n\nlet graph = {1: @[2, 3], 2: @[4], 3: @[4], 4: newSeq[int]()}.toTable\necho bfs(graph, 1)", "note": ""}
{"topic": "DFS tren do thi (Depth-First Search)", "language": "python", "code": "def dfs(graph, start, visited=None, order=None):\n if visited is None:\n visited = set()\n order = []\n visited.add(start)\n order.append(start)\n for neighbor in graph[start]:\n if neighbor not in visited:\n dfs(graph, neighbor, visited, order)\n return order\n\ngraph = {1: [2, 3], 2: [4], 3: [4], 4: []}\nprint(dfs(graph, 1))", "note": ""}
{"topic": "DFS tren do thi (Depth-First Search)", "language": "nim", "code": "import std/[tables, sets]\n\nproc dfs(graph: Table[int, seq[int]], start: int, visited: var HashSet[int], order: var seq[int]) =\n visited.incl(start)\n order.add(start)\n for neighbor in graph[start]:\n if neighbor notin visited:\n dfs(graph, neighbor, visited, order)\n\nlet graph = {1: @[2, 3], 2: @[4], 3: @[4], 4: newSeq[int]()}.toTable\nvar visited = initHashSet[int]()\nvar order: seq[int] = @[]\ndfs(graph, 1, visited, order)\necho order", "note": ""}
{"topic": "Bang bam (Hash Table) tu cai dat don gian", "language": "python", "code": "class HashTable:\n def __init__(self, size=10):\n self.size = size\n self.buckets = [[] for _ in range(size)]\n\n def _hash(self, key):\n return sum(ord(c) for c in key) % self.size\n\n def set(self, key, value):\n idx = self._hash(key)\n for pair in self.buckets[idx]:\n if pair[0] == key:\n pair[1] = value\n return\n self.buckets[idx].append([key, value])\n\n def get(self, key):\n idx = self._hash(key)\n for pair in self.buckets[idx]:\n if pair[0] == key:\n return pair[1]\n return None\n\nht = HashTable()\nht.set(\"name\", \"Python\")\nprint(ht.get(\"name\"))", "note": ""}
{"topic": "Bang bam (Hash Table) tu cai dat don gian", "language": "nim", "code": "type\n HashTable = object\n buckets: seq[seq[(string, string)]]\n size: int\n\nproc newHashTable(size: int = 10): HashTable =\n result.size = size\n result.buckets = newSeq[seq[(string, string)]](size)\n\nproc hashKey(key: string, size: int): int =\n var s = 0\n for c in key:\n s += ord(c)\n return s mod size\n\nproc set(ht: var HashTable, key, value: string) =\n let idx = hashKey(key, ht.size)\n for i in 0..<ht.buckets[idx].len:\n if ht.buckets[idx][i][0] == key:\n ht.buckets[idx][i][1] = value\n return\n ht.buckets[idx].add((key, value))\n\nproc get(ht: HashTable, key: string): string =\n let idx = hashKey(key, ht.size)\n for pair in ht.buckets[idx]:\n if pair[0] == key:\n return pair[1]\n return \"\"\n\nvar ht = newHashTable()\nht.set(\"name\", \"Nim\")\necho ht.get(\"name\")", "note": ""}
{"topic": "Kiem tra chuoi doi xung (Palindrome)", "language": "python", "code": "def is_palindrome(s):\n s = s.lower().replace(\" \", \"\")\n return s == s[::-1]\n\nprint(is_palindrome(\"madam\"))\nprint(is_palindrome(\"hello\"))", "note": ""}
{"topic": "Kiem tra chuoi doi xung (Palindrome)", "language": "nim", "code": "import std/strutils\n\nproc isPalindrome(s: string): bool =\n let clean = s.toLowerAscii().replace(\" \", \"\")\n return clean == clean.reversed()\n\necho isPalindrome(\"madam\")\necho isPalindrome(\"hello\")", "note": ""}
{"topic": "Kiem tra anagram", "language": "python", "code": "def is_anagram(a, b):\n return sorted(a) == sorted(b)\n\nprint(is_anagram(\"listen\", \"silent\"))\nprint(is_anagram(\"hello\", \"world\"))", "note": ""}
{"topic": "Kiem tra anagram", "language": "nim", "code": "import std/algorithm\n\nproc isAnagram(a, b: string): bool =\n var x = a\n var y = b\n x.sort()\n y.sort()\n return x == y\n\necho isAnagram(\"listen\", \"silent\")\necho isAnagram(\"hello\", \"world\")", "note": ""}
{"topic": "Dao nguoc chuoi", "language": "python", "code": "s = \"Hello, Python!\"\nprint(s[::-1])", "note": ""}
{"topic": "Dao nguoc chuoi", "language": "nim", "code": "import std/algorithm\n\nvar s = \"Hello, Nim!\"\necho s.reversed()", "note": ""}
{"topic": "Dem tan so tu trong chuoi", "language": "python", "code": "from collections import Counter\n\ns = \"con meo con cho con ga\"\nwords = s.split()\ncounter = Counter(words)\nprint(counter)", "note": ""}
{"topic": "Dem tan so tu trong chuoi", "language": "nim", "code": "import std/[tables, strutils]\n\nlet s = \"con meo con cho con ga\"\nlet words = s.split(\" \")\nvar counter = initCountTable[string]()\nfor w in words:\n counter.inc(w)\necho counter", "note": ""}
{"topic": "Sap xep chen (Insertion sort)", "language": "python", "code": "def insertion_sort(arr):\n for i in range(1, len(arr)):\n key = arr[i]\n j = i - 1\n while j >= 0 and arr[j] > key:\n arr[j + 1] = arr[j]\n j -= 1\n arr[j + 1] = key\n return arr\n\nprint(insertion_sort([9, 5, 1, 4, 3]))", "note": ""}
{"topic": "Sap xep chen (Insertion sort)", "language": "nim", "code": "proc insertionSort(arr: var seq[int]) =\n for i in 1..<arr.len:\n let key = arr[i]\n var j = i - 1\n while j >= 0 and arr[j] > key:\n arr[j + 1] = arr[j]\n dec j\n arr[j + 1] = key\n\nvar arr = @[9, 5, 1, 4, 3]\ninsertionSort(arr)\necho arr", "note": ""}
{"topic": "Sap xep chon (Selection sort)", "language": "python", "code": "def selection_sort(arr):\n n = len(arr)\n for i in range(n):\n min_idx = i\n for j in range(i + 1, n):\n if arr[j] < arr[min_idx]:\n min_idx = j\n arr[i], arr[min_idx] = arr[min_idx], arr[i]\n return arr\n\nprint(selection_sort([64, 25, 12, 22, 11]))", "note": ""}
{"topic": "Sap xep chon (Selection sort)", "language": "nim", "code": "proc selectionSort(arr: var seq[int]) =\n let n = arr.len\n for i in 0..<n:\n var minIdx = i\n for j in i + 1..<n:\n if arr[j] < arr[minIdx]:\n minIdx = j\n swap(arr[i], arr[minIdx])\n\nvar arr = @[64, 25, 12, 22, 11]\nselectionSort(arr)\necho arr", "note": ""}
{"topic": "Sap xep tron (Merge sort)", "language": "python", "code": "def merge_sort(arr):\n if len(arr) <= 1:\n return arr\n mid = len(arr) // 2\n left = merge_sort(arr[:mid])\n right = merge_sort(arr[mid:])\n result = []\n i = j = 0\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n result.append(left[i]); i += 1\n else:\n result.append(right[j]); j += 1\n result.extend(left[i:])\n result.extend(right[j:])\n return result\n\nprint(merge_sort([38, 27, 43, 3, 9, 82, 10]))", "note": ""}
{"topic": "Sap xep tron (Merge sort)", "language": "nim", "code": "proc mergeSort(arr: seq[int]): seq[int] =\n if arr.len <= 1:\n return arr\n let mid = arr.len div 2\n let left = mergeSort(arr[0..<mid])\n let right = mergeSort(arr[mid..^1])\n var res: seq[int] = @[]\n var i = 0\n var j = 0\n while i < left.len and j < right.len:\n if left[i] < right[j]:\n res.add(left[i]); inc i\n else:\n res.add(right[j]); inc j\n while i < left.len:\n res.add(left[i]); inc i\n while j < right.len:\n res.add(right[j]); inc j\n return res\n\necho mergeSort(@[38, 27, 43, 3, 9, 82, 10])", "note": ""}
{"topic": "Tim kiem tuyen tinh (Linear search)", "language": "python", "code": "def linear_search(arr, target):\n for i, v in enumerate(arr):\n if v == target:\n return i\n return -1\n\nprint(linear_search([4, 2, 7, 1, 9], 7))", "note": ""}
{"topic": "Tim kiem tuyen tinh (Linear search)", "language": "nim", "code": "proc linearSearch(arr: seq[int], target: int): int =\n for i, v in arr:\n if v == target:\n return i\n return -1\n\necho linearSearch(@[4, 2, 7, 1, 9], 7)", "note": ""}
{"topic": "Tim gia tri lon nhat/nho nhat trong mang", "language": "python", "code": "arr = [4, 2, 7, 1, 9]\nprint(max(arr), min(arr))", "note": ""}
{"topic": "Tim gia tri lon nhat/nho nhat trong mang", "language": "nim", "code": "import std/[algorithm, sequtils]\n\nlet arr = @[4, 2, 7, 1, 9]\necho max(arr), \" \", min(arr)", "note": ""}
{"topic": "Tong cac phan tu trong mang", "language": "python", "code": "arr = [1, 2, 3, 4, 5]\nprint(sum(arr))", "note": ""}
{"topic": "Tong cac phan tu trong mang", "language": "nim", "code": "import std/sequtils\n\nlet arr = @[1, 2, 3, 4, 5]\necho arr.foldl(a + b)", "note": ""}
{"topic": "Dao nguoc mang", "language": "python", "code": "arr = [1, 2, 3, 4, 5]\nprint(arr[::-1])", "note": ""}
{"topic": "Dao nguoc mang", "language": "nim", "code": "import std/algorithm\n\nvar arr = @[1, 2, 3, 4, 5]\necho arr.reversed()", "note": ""}
{"topic": "Xoay mang (rotate array)", "language": "python", "code": "def rotate(arr, k):\n n = len(arr)\n k = k % n\n return arr[-k:] + arr[:-k]\n\nprint(rotate([1, 2, 3, 4, 5], 2))", "note": ""}
{"topic": "Xoay mang (rotate array)", "language": "nim", "code": "proc rotate(arr: seq[int], k: int): seq[int] =\n let n = arr.len\n let kk = k mod n\n return arr[n - kk..^1] & arr[0..<n - kk]\n\necho rotate(@[1, 2, 3, 4, 5], 2)", "note": ""}
{"topic": "Tim phan tu trung lap trong mang", "language": "python", "code": "def find_duplicates(arr):\n seen = set()\n dups = set()\n for x in arr:\n if x in seen:\n dups.add(x)\n seen.add(x)\n return list(dups)\n\nprint(find_duplicates([1, 2, 3, 2, 4, 1]))", "note": ""}
{"topic": "Tim phan tu trung lap trong mang", "language": "nim", "code": "import std/sets\n\nproc findDuplicates(arr: seq[int]): seq[int] =\n var seen = initHashSet[int]()\n var dups = initHashSet[int]()\n for x in arr:\n if x in seen:\n dups.incl(x)\n seen.incl(x)\n return dups.toSeq()\n\necho findDuplicates(@[1, 2, 3, 2, 4, 1])", "note": ""}
{"topic": "Bai toan Two Sum", "language": "python", "code": "def two_sum(arr, target):\n seen = {}\n for i, v in enumerate(arr):\n need = target - v\n if need in seen:\n return [seen[need], i]\n seen[v] = i\n return []\n\nprint(two_sum([2, 7, 11, 15], 9))", "note": ""}
{"topic": "Bai toan Two Sum", "language": "nim", "code": "import std/tables\n\nproc twoSum(arr: seq[int], target: int): seq[int] =\n var seen = initTable[int, int]()\n for i, v in arr:\n let need = target - v\n if seen.hasKey(need):\n return @[seen[need], i]\n seen[v] = i\n return @[]\n\necho twoSum(@[2, 7, 11, 15], 9)", "note": ""}
{"topic": "Tinh BCNN (LCM)", "language": "python", "code": "def gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\ndef lcm(a, b):\n return a * b // gcd(a, b)\n\nprint(lcm(4, 6))", "note": ""}
{"topic": "Tinh BCNN (LCM)", "language": "nim", "code": "proc gcd(a, b: int): int =\n var a = a\n var b = b\n while b != 0:\n let t = b\n b = a mod b\n a = t\n return a\n\nproc lcm(a, b: int): int =\n return a * b div gcd(a, b)\n\necho lcm(4, 6)", "note": ""}
{"topic": "Phan tich thua so nguyen to", "language": "python", "code": "def prime_factors(n):\n factors = []\n d = 2\n while d * d <= n:\n while n % d == 0:\n factors.append(d)\n n //= d\n d += 1\n if n > 1:\n factors.append(n)\n return factors\n\nprint(prime_factors(360))", "note": ""}
{"topic": "Phan tich thua so nguyen to", "language": "nim", "code": "proc primeFactors(n: int): seq[int] =\n var n = n\n var factors: seq[int] = @[]\n var d = 2\n while d * d <= n:\n while n mod d == 0:\n factors.add(d)\n n = n div d\n inc d\n if n > 1:\n factors.add(n)\n return factors\n\necho primeFactors(360)", "note": ""}
{"topic": "Tinh luy thua (power function)", "language": "python", "code": "def power(base, exp):\n if exp == 0:\n return 1\n return base * power(base, exp - 1)\n\nprint(power(2, 10))", "note": ""}
{"topic": "Tinh luy thua (power function)", "language": "nim", "code": "proc power(base, exp: int): int =\n if exp == 0:\n return 1\n return base * power(base, exp - 1)\n\necho power(2, 10)", "note": ""}
{"topic": "Tong cac chu so cua mot so", "language": "python", "code": "def sum_digits(n):\n total = 0\n n = abs(n)\n while n > 0:\n total += n % 10\n n //= 10\n return total\n\nprint(sum_digits(12345))", "note": ""}
{"topic": "Tong cac chu so cua mot so", "language": "nim", "code": "proc sumDigits(n: int): int =\n var n = abs(n)\n var total = 0\n while n > 0:\n total += n mod 10\n n = n div 10\n return total\n\necho sumDigits(12345)", "note": ""}
{"topic": "Iterator/Generator (yield)", "language": "python", "code": "def counter(limit):\n n = 0\n while n < limit:\n yield n\n n += 1\n\nfor x in counter(5):\n print(x)", "note": ""}
{"topic": "Iterator/Generator (yield)", "language": "nim", "code": "iterator counter(limit: int): int =\n var n = 0\n while n < limit:\n yield n\n inc n\n\nfor x in counter(5):\n echo x", "note": ""}
{"topic": "Decorator (python)", "language": "python", "code": "def log_call(func):\n def wrapper(*args, **kwargs):\n print(f\"Goi ham {func.__name__}\")\n return func(*args, **kwargs)\n return wrapper\n\n@log_call\ndef greet(name):\n print(f\"Xin chao, {name}\")\n\ngreet(\"Nam\")", "note": ""}
{"topic": "Template (nim) - tuong duong decorator", "language": "nim", "code": "import std/macros\n\ntemplate logCall(body: untyped): untyped =\n echo \"Goi ham\"\n body\n\nproc greet(name: string) =\n logCall:\n echo \"Xin chao, \", name\n\ngreet(\"Nam\")", "note": ""}
{"topic": "Context manager (with)", "language": "python", "code": "class Timer:\n def __enter__(self):\n print(\"Bat dau\")\n return self\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n print(\"Ket thuc\")\n\nwith Timer():\n print(\"Dang xu ly...\")", "note": ""}
{"topic": "Defer (tuong duong context manager)", "language": "nim", "code": "proc doWork() =\n echo \"Bat dau\"\n defer: echo \"Ket thuc\"\n echo \"Dang xu ly...\"\n\ndoWork()", "note": ""}
{"topic": "Enum", "language": "python", "code": "from enum import Enum\n\nclass Color(Enum):\n RED = 1\n GREEN = 2\n BLUE = 3\n\nprint(Color.RED)\nprint(Color.RED.value)", "note": ""}
{"topic": "Enum", "language": "nim", "code": "type\n Color = enum\n Red, Green, Blue\n\necho Red\necho ord(Red)", "note": ""}
{"topic": "Ham generic (Generic function)", "language": "python", "code": "from typing import TypeVar, List\n\nT = TypeVar(\"T\")\n\ndef first_element(items: List[T]) -> T:\n return items[0]\n\nprint(first_element([1, 2, 3]))\nprint(first_element([\"a\", \"b\", \"c\"]))", "note": ""}
{"topic": "Ham generic (Generic function)", "language": "nim", "code": "proc firstElement[T](items: seq[T]): T =\n return items[0]\n\necho firstElement(@[1, 2, 3])\necho firstElement(@[\"a\", \"b\", \"c\"])", "note": ""}
{"topic": "Ngoai le tuy chinh (Custom exception)", "language": "python", "code": "class InsufficientFundsError(Exception):\n pass\n\ndef withdraw(balance, amount):\n if amount > balance:\n raise InsufficientFundsError(\"Khong du tien\")\n return balance - amount\n\ntry:\n withdraw(100, 200)\nexcept InsufficientFundsError as e:\n print(e)", "note": ""}
{"topic": "Ngoai le tuy chinh (Custom exception)", "language": "nim", "code": "type\n InsufficientFundsError = object of CatchableError\n\nproc withdraw(balance, amount: int): int =\n if amount > balance:\n raise newException(InsufficientFundsError, \"Khong du tien\")\n return balance - amount\n\ntry:\n discard withdraw(100, 200)\nexcept InsufficientFundsError as e:\n echo e.msg", "note": ""}
{"topic": "Regex co ban", "language": "python", "code": "import re\n\ntext = \"So dien thoai: 0987654321\"\nmatch = re.search(r\"\\d{10}\", text)\nif match:\n print(match.group())", "note": ""}
{"topic": "Regex co ban", "language": "nim", "code": "import std/re\n\nlet text = \"So dien thoai: 0987654321\"\nlet m = text.findAll(re\"\\d{10}\")\necho m", "note": ""}
{"topic": "Lam viec voi ngay thang (date/time)", "language": "python", "code": "from datetime import datetime\n\nnow = datetime.now()\nprint(now.strftime(\"%Y-%m-%d %H:%M:%S\"))", "note": ""}
{"topic": "Lam viec voi ngay thang (date/time)", "language": "nim", "code": "import std/times\n\nlet now = now()\necho now.format(\"yyyy-MM-dd HH:mm:ss\")", "note": ""}
{"topic": "So ngau nhien (random)", "language": "python", "code": "import random\n\nprint(random.randint(1, 100))\nprint(random.choice([\"a\", \"b\", \"c\"]))", "note": ""}
{"topic": "So ngau nhien (random)", "language": "nim", "code": "import std/random\n\nrandomize()\necho rand(1..100)\necho sample([\"a\", \"b\", \"c\"])", "note": ""}
{"topic": "Doc tham so dong lenh (command line args)", "language": "python", "code": "import sys\n\nfor arg in sys.argv[1:]:\n print(arg)", "note": ""}
{"topic": "Doc tham so dong lenh (command line args)", "language": "nim", "code": "import std/os\n\nfor arg in commandLineParams():\n echo arg", "note": ""}
{"topic": "Lam viec voi JSON", "language": "python", "code": "import json\n\ndata = {\"name\": \"Nam\", \"age\": 25}\njson_str = json.dumps(data)\nprint(json_str)\n\nparsed = json.loads(json_str)\nprint(parsed[\"name\"])", "note": ""}
{"topic": "Lam viec voi JSON", "language": "nim", "code": "import std/json\n\nlet data = %*{\"name\": \"Nam\", \"age\": 25}\nlet jsonStr = $data\necho jsonStr\n\nlet parsed = parseJson(jsonStr)\necho parsed[\"name\"].getStr()", "note": ""}
{"topic": "Ham reduce/fold", "language": "python", "code": "from functools import reduce\n\nnums = [1, 2, 3, 4, 5]\ntotal = reduce(lambda acc, x: acc + x, nums, 0)\nprint(total)", "note": ""}
{"topic": "Ham reduce/fold", "language": "nim", "code": "import std/sequtils\n\nlet nums = @[1, 2, 3, 4, 5]\nlet total = nums.foldl(a + b, 0)\necho total", "note": ""}
{"topic": "Closure (ham dong)", "language": "python", "code": "def make_counter():\n count = 0\n def increment():\n nonlocal count\n count += 1\n return count\n return increment\n\ncounter = make_counter()\nprint(counter())\nprint(counter())\nprint(counter())", "note": ""}
{"topic": "Closure (ham dong)", "language": "nim", "code": "proc makeCounter(): proc(): int =\n var count = 0\n return proc(): int =\n inc count\n return count\n\nlet counter = makeCounter()\necho counter()\necho counter()\necho counter()", "note": ""}
{"topic": "Sap xep voi key tuy chinh", "language": "python", "code": "people = [(\"An\", 25), (\"Binh\", 20), (\"Chi\", 30)]\npeople.sort(key=lambda p: p[1])\nprint(people)", "note": ""}
{"topic": "Sap xep voi key tuy chinh", "language": "nim", "code": "import std/algorithm\n\nvar people = @[(\"An\", 25), (\"Binh\", 20), (\"Chi\", 30)]\npeople.sort(proc(a, b: (string, int)): int = cmp(a[1], b[1]))\necho people", "note": ""}
{"topic": "Xu ly da luong co ban (threads)", "language": "python", "code": "import threading\n\ndef print_numbers():\n for i in range(5):\n print(i)\n\nt = threading.Thread(target=print_numbers)\nt.start()\nt.join()", "note": ""}
{"topic": "Xu ly da luong co ban (threads)", "language": "nim", "code": "import std/os\n\nproc printNumbers() {.thread.} =\n for i in 0..<5:\n echo i\n\nvar t: Thread[void]\ncreateThread(t, printNumbers)\njoinThread(t)", "note": ""}
{"topic": "Dinh dang chuoi (f-string)", "language": "python", "code": "name = \"Nam\"\nage = 25\nprint(f\"{name} nam nay {age} tuoi\")", "note": ""}
{"topic": "Dinh dang chuoi (strformat)", "language": "nim", "code": "import std/strformat\n\nlet name = \"Nam\"\nlet age = 25\necho &\"{name} nam nay {age} tuoi\"", "note": ""}
{"topic": "Nap chong toan tu (operator overloading)", "language": "python", "code": "class Point:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n\n def __add__(self, other):\n return Point(self.x + other.x, self.y + other.y)\n\n def __repr__(self):\n return f\"Point({self.x}, {self.y})\"\n\np1 = Point(1, 2)\np2 = Point(3, 4)\nprint(p1 + p2)", "note": ""}
{"topic": "Nap chong toan tu (operator overloading)", "language": "nim", "code": "type\n Point = object\n x, y: int\n\nproc `+`(a, b: Point): Point =\n Point(x: a.x + b.x, y: a.y + b.y)\n\nproc `$`(p: Point): string =\n \"Point(\" & $p.x & \", \" & $p.y & \")\"\n\nlet p1 = Point(x: 1, y: 2)\nlet p2 = Point(x: 3, y: 4)\necho p1 + p2", "note": ""}
{"topic": "Named tuple", "language": "python", "code": "from collections import namedtuple\n\nPoint = namedtuple(\"Point\", [\"x\", \"y\"])\np = Point(1, 2)\nprint(p.x, p.y)", "note": ""}
{"topic": "Object variant (tuong duong named tuple)", "language": "nim", "code": "type\n Point = object\n x, y: int\n\nlet p = Point(x: 1, y: 2)\necho p.x, \" \", p.y", "note": ""}
{"topic": "Cat lat mang/chuoi (slicing)", "language": "python", "code": "arr = [1, 2, 3, 4, 5, 6]\nprint(arr[1:4])\nprint(arr[:3])\nprint(arr[3:])", "note": ""}
{"topic": "Cat lat mang/chuoi (slicing)", "language": "nim", "code": "let arr = @[1, 2, 3, 4, 5, 6]\necho arr[1..3]\necho arr[0..2]\necho arr[3..^1]", "note": ""}
{"topic": "Kiem tra so chinh phuong va so hoan hao", "language": "python", "code": "import math\n\ndef is_perfect_square(n):\n root = int(math.isqrt(n))\n return root * root == n\n\ndef is_perfect_number(n):\n total = sum(i for i in range(1, n) if n % i == 0)\n return total == n\n\nprint(is_perfect_square(16))\nprint(is_perfect_number(28))", "note": ""}
{"topic": "Kiem tra so chinh phuong va so hoan hao", "language": "nim", "code": "import std/math\n\nproc isPerfectSquare(n: int): bool =\n let root = sqrt(n.float).int\n return root * root == n\n\nproc isPerfectNumber(n: int): bool =\n var total = 0\n for i in 1..<n:\n if n mod i == 0:\n total += i\n return total == n\n\necho isPerfectSquare(16)\necho isPerfectNumber(28)", "note": ""}
{"topic": "Day so tam giac Pascal (Pascal's triangle)", "language": "python", "code": "def pascals_triangle(n):\n triangle = []\n for i in range(n):\n row = [1] * (i + 1)\n for j in range(1, i):\n row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]\n triangle.append(row)\n return triangle\n\nfor row in pascals_triangle(5):\n print(row)", "note": ""}
{"topic": "Day so tam giac Pascal (Pascal's triangle)", "language": "nim", "code": "proc pascalsTriangle(n: int): seq[seq[int]] =\n var triangle: seq[seq[int]] = @[]\n for i in 0..<n:\n var row = newSeq[int](i + 1)\n row[0] = 1\n row[i] = 1\n for j in 1..<i:\n row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]\n triangle.add(row)\n return triangle\n\nfor row in pascalsTriangle(5):\n echo row", "note": ""}
{"topic": "Ma tran (2D array) - tao va duyet", "language": "python", "code": "matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\nfor row in matrix:\n for val in row:\n print(val, end=\" \")\n print()", "note": ""}
{"topic": "Ma tran (2D array) - tao va duyet", "language": "nim", "code": "let matrix = @[@[1, 2, 3], @[4, 5, 6], @[7, 8, 9]]\nfor row in matrix:\n for val in row:\n stdout.write(val, \" \")\n echo \"\"\n\n", "note": ""}
{"topic": "Nhan ma tran (matrix multiplication)", "language": "python", "code": "def multiply(a, b):\n rows_a, cols_a = len(a), len(a[0])\n cols_b = len(b[0])\n result = [[0] * cols_b for _ in range(rows_a)]\n for i in range(rows_a):\n for j in range(cols_b):\n for k in range(cols_a):\n result[i][j] += a[i][k] * b[k][j]\n return result\n\na = [[1, 2], [3, 4]]\nb = [[5, 6], [7, 8]]\nprint(multiply(a, b))", "note": ""}
{"topic": "Nhan ma tran (matrix multiplication)", "language": "nim", "code": "proc multiply(a, b: seq[seq[int]]): seq[seq[int]] =\n let rowsA = a.len\n let colsA = a[0].len\n let colsB = b[0].len\n var res = newSeqWith(rowsA, newSeq[int](colsB))\n for i in 0..<rowsA:\n for j in 0..<colsB:\n for k in 0..<colsA:\n res[i][j] += a[i][k] * b[k][j]\n return res\n\nimport std/sequtils\nlet a = @[@[1, 2], @[3, 4]]\nlet b = @[@[5, 6], @[7, 8]]\necho multiply(a, b)", "note": ""}
{"topic": "Chuyen doi so sang he nhi phan", "language": "python", "code": "def to_binary(n):\n if n == 0:\n return \"0\"\n bits = \"\"\n while n > 0:\n bits = str(n % 2) + bits\n n //= 2\n return bits\n\nprint(to_binary(42))\nprint(bin(42))", "note": ""}
{"topic": "Chuyen doi so sang he nhi phan", "language": "nim", "code": "proc toBinary(n: int): string =\n if n == 0:\n return \"0\"\n var n = n\n var bits = \"\"\n while n > 0:\n bits = $(n mod 2) & bits\n n = n div 2\n return bits\n\necho toBinary(42)\necho toBin(42, 8)", "note": ""}
{"topic": "HTTP GET request", "language": "python", "code": "import urllib.request\n\nwith urllib.request.urlopen(\"https://api.github.com\") as response:\n data = response.read()\n print(data[:100])", "note": ""}
{"topic": "HTTP GET request", "language": "nim", "code": "import std/httpclient\n\nlet client = newHttpClient()\nlet response = client.getContent(\"https://api.github.com\")\necho response[0..100]", "note": ""}
{"topic": "HTTP POST request", "language": "python", "code": "import urllib.request\nimport json\n\ndata = json.dumps({\"key\": \"value\"}).encode()\nreq = urllib.request.Request(\"https://httpbin.org/post\", data=data, method=\"POST\")\nwith urllib.request.urlopen(req) as response:\n print(response.read())", "note": ""}
{"topic": "HTTP POST request", "language": "nim", "code": "import std/httpclient\n\nlet client = newHttpClient()\nlet response = client.postContent(\"https://httpbin.org/post\", body = \"\"\"{\"key\":\"value\"}\"\"\")\necho response", "note": ""}
{"topic": "Lam viec voi SQLite (tao bang, insert, query)", "language": "python", "code": "import sqlite3\n\nconn = sqlite3.connect(\":memory:\")\ncur = conn.cursor()\ncur.execute(\"CREATE TABLE users (id INTEGER, name TEXT)\")\ncur.execute(\"INSERT INTO users VALUES (1, 'An')\")\nconn.commit()\ncur.execute(\"SELECT * FROM users\")\nprint(cur.fetchall())\nconn.close()", "note": ""}
{"topic": "Lam viec voi SQLite (tao bang, insert, query)", "language": "nim", "code": "import std/db_sqlite\n\nlet db = open(\":memory:\", \"\", \"\", \"\")\ndb.exec(sql\"CREATE TABLE users (id INTEGER, name TEXT)\")\ndb.exec(sql\"INSERT INTO users VALUES (?, ?)\", 1, \"An\")\nfor row in db.rows(sql\"SELECT * FROM users\"):\n echo row\ndb.close()", "note": ""}
{"topic": "Async/await co ban", "language": "python", "code": "import asyncio\n\nasync def say_hello():\n await asyncio.sleep(1)\n print(\"Xin chao!\")\n\nasyncio.run(say_hello())", "note": ""}
{"topic": "Async/await co ban", "language": "nim", "code": "import std/asyncdispatch\n\nproc sayHello() {.async.} =\n await sleepAsync(1000)\n echo \"Xin chao!\"\n\nwaitFor sayHello()", "note": ""}
{"topic": "Unit test co ban", "language": "python", "code": "import unittest\n\ndef add(a, b):\n return a + b\n\nclass TestAdd(unittest.TestCase):\n def test_add(self):\n self.assertEqual(add(2, 3), 5)\n\nif __name__ == \"__main__\":\n unittest.main()", "note": ""}
{"topic": "Unit test co ban", "language": "nim", "code": "import std/unittest\n\nproc add(a, b: int): int = a + b\n\nsuite \"test add\":\n test \"cong hai so\":\n check add(2, 3) == 5", "note": ""}
{"topic": "Design pattern Singleton", "language": "python", "code": "class Singleton:\n _instance = None\n\n def __new__(cls):\n if cls._instance is None:\n cls._instance = super().__new__(cls)\n return cls._instance\n\na = Singleton()\nb = Singleton()\nprint(a is b)", "note": ""}
{"topic": "Design pattern Singleton", "language": "nim", "code": "var instance {.threadvar.}: ref int\n\nproc getInstance(): ref int =\n if instance.isNil:\n instance = new(int)\n instance[] = 42\n return instance\n\nlet a = getInstance()\nlet b = getInstance()\necho a == b", "note": ""}
{"topic": "Design pattern Factory", "language": "python", "code": "class Dog:\n def speak(self):\n return \"Gau gau\"\n\nclass Cat:\n def speak(self):\n return \"Meo meo\"\n\ndef animal_factory(kind):\n if kind == \"dog\":\n return Dog()\n return Cat()\n\na = animal_factory(\"dog\")\nprint(a.speak())", "note": ""}
{"topic": "Design pattern Factory", "language": "nim", "code": "type\n Animal = ref object of RootObj\n\n Dog = ref object of Animal\n Cat = ref object of Animal\n\nmethod speak(a: Animal): string {.base.} = \"\"\nmethod speak(d: Dog): string = \"Gau gau\"\nmethod speak(c: Cat): string = \"Meo meo\"\n\nproc animalFactory(kind: string): Animal =\n if kind == \"dog\":\n return Dog()\n return Cat()\n\nlet a = animalFactory(\"dog\")\necho a.speak()", "note": ""}
{"topic": "Design pattern Observer", "language": "python", "code": "class Subject:\n def __init__(self):\n self.observers = []\n\n def subscribe(self, fn):\n self.observers.append(fn)\n\n def notify(self, msg):\n for fn in self.observers:\n fn(msg)\n\ndef logger(msg):\n print(f\"Log: {msg}\")\n\ns = Subject()\ns.subscribe(logger)\ns.notify(\"su kien xay ra\")", "note": ""}
{"topic": "Design pattern Observer", "language": "nim", "code": "type\n Subject = object\n observers: seq[proc(msg: string)]\n\nproc subscribe(s: var Subject, fn: proc(msg: string)) =\n s.observers.add(fn)\n\nproc notify(s: Subject, msg: string) =\n for fn in s.observers:\n fn(msg)\n\nproc logger(msg: string) =\n echo \"Log: \", msg\n\nvar s = Subject()\ns.subscribe(logger)\ns.notify(\"su kien xay ra\")", "note": ""}
{"topic": "Design pattern Strategy", "language": "python", "code": "def add_strategy(a, b):\n return a + b\n\ndef mul_strategy(a, b):\n return a * b\n\nclass Calculator:\n def __init__(self, strategy):\n self.strategy = strategy\n\n def execute(self, a, b):\n return self.strategy(a, b)\n\ncalc = Calculator(add_strategy)\nprint(calc.execute(3, 4))", "note": ""}
{"topic": "Design pattern Strategy", "language": "nim", "code": "type\n Calculator = object\n strategy: proc(a, b: int): int\n\nproc execute(c: Calculator, a, b: int): int =\n return c.strategy(a, b)\n\nlet addStrategy = proc(a, b: int): int = a + b\nlet calc = Calculator(strategy: addStrategy)\necho calc.execute(3, 4)", "note": ""}
{"topic": "Xu ly song song (multiprocessing)", "language": "python", "code": "from multiprocessing import Pool\n\ndef square(x):\n return x * x\n\nif __name__ == \"__main__\":\n with Pool(4) as p:\n print(p.map(square, [1, 2, 3, 4, 5]))", "note": ""}
{"topic": "Xu ly song song (threads trong Nim)", "language": "nim", "code": "import std/[os, threadpool]\n\nproc square(x: int): int =\n return x * x\n\nvar results: seq[FlowVar[int]] = @[]\nfor i in 1..5:\n results.add(spawn square(i))\n\nfor r in results:\n echo ^r", "note": ""}
{"topic": "He thong ngoai le tuy chinh (exception hierarchy)", "language": "python", "code": "class AppError(Exception):\n pass\n\nclass NotFoundError(AppError):\n pass\n\nclass ValidationError(AppError):\n pass\n\ntry:\n raise NotFoundError(\"Khong tim thay\")\nexcept AppError as e:\n print(f\"Loi ung dung: {e}\")", "note": ""}
{"topic": "He thong ngoai le tuy chinh (exception hierarchy)", "language": "nim", "code": "type\n AppError = object of CatchableError\n NotFoundError = object of AppError\n ValidationError = object of AppError\n\ntry:\n raise newException(NotFoundError, \"Khong tim thay\")\nexcept AppError as e:\n echo \"Loi ung dung: \", e.msg", "note": ""}
{"topic": "Serialization/deserialization (pickle)", "language": "python", "code": "import pickle\n\ndata = {\"name\": \"An\", \"age\": 25}\nserialized = pickle.dumps(data)\nrestored = pickle.loads(serialized)\nprint(restored)", "note": ""}
{"topic": "Serialization/deserialization (JSON)", "language": "nim", "code": "import std/json\n\nlet data = %*{\"name\": \"An\", \"age\": 25}\nlet serialized = $data\nlet restored = parseJson(serialized)\necho restored", "note": ""}
{"topic": "Xu ly file CSV", "language": "python", "code": "import csv\n\nwith open(\"data.csv\", \"w\", newline=\"\") as f:\n writer = csv.writer(f)\n writer.writerow([\"ten\", \"tuoi\"])\n writer.writerow([\"An\", 25])\n\nwith open(\"data.csv\", \"r\") as f:\n reader = csv.reader(f)\n for row in reader:\n print(row)", "note": ""}
{"topic": "Xu ly file CSV", "language": "nim", "code": "import std/[parsecsv, streams]\n\nvar f = newFileStream(\"data.csv\", fmWrite)\nf.writeLine(\"ten,tuoi\")\nf.writeLine(\"An,25\")\nf.close()\n\nvar parser: CsvParser\nparser.open(\"data.csv\")\nwhile parser.readRow():\n echo parser.row\nparser.close()", "note": ""}
{"topic": "Xu ly file XML", "language": "python", "code": "import xml.etree.ElementTree as ET\n\nroot = ET.Element(\"root\")\nchild = ET.SubElement(root, \"user\")\nchild.set(\"name\", \"An\")\ntree = ET.ElementTree(root)\nprint(ET.tostring(root))", "note": ""}
{"topic": "Xu ly file XML", "language": "nim", "code": "import std/xmltree\n\nvar root = newElement(\"root\")\nvar child = newElement(\"user\")\nchild.attrs = {\"name\": \"An\"}.toXmlAttributes\nroot.add(child)\necho $root", "note": ""}
{"topic": "Ghi log (logging)", "language": "python", "code": "import logging\n\nlogging.basicConfig(level=logging.INFO)\nlogging.info(\"Ung dung da khoi dong\")\nlogging.warning(\"Day la canh bao\")\nlogging.error(\"Da xay ra loi\")", "note": ""}
{"topic": "Ghi log (logging)", "language": "nim", "code": "import std/logging\n\nvar logger = newConsoleLogger()\naddHandler(logger)\ninfo(\"Ung dung da khoi dong\")\nwarn(\"Day la canh bao\")\nerror(\"Da xay ra loi\")", "note": ""}
{"topic": "Bien moi truong (environment variables)", "language": "python", "code": "import os\n\nos.environ[\"MY_VAR\"] = \"hello\"\nprint(os.environ.get(\"MY_VAR\"))\nprint(os.getenv(\"PATH_KHONG_TON_TAI\", \"gia tri mac dinh\"))", "note": ""}
{"topic": "Bien moi truong (environment variables)", "language": "nim", "code": "import std/os\n\nputEnv(\"MY_VAR\", \"hello\")\necho getEnv(\"MY_VAR\")\necho getEnv(\"PATH_KHONG_TON_TAI\", \"gia tri mac dinh\")", "note": ""}
{"topic": "Argparse nang cao (command line parser)", "language": "python", "code": "import argparse\n\nparser = argparse.ArgumentParser(description=\"Vi du argparse\")\nparser.add_argument(\"--name\", type=str, default=\"World\")\nparser.add_argument(\"--count\", type=int, default=1)\nargs = parser.parse_args()\nfor _ in range(args.count):\n print(f\"Xin chao, {args.name}!\")", "note": ""}
{"topic": "Argparse nang cao (command line parser)", "language": "nim", "code": "import std/parseopt\n\nvar name = \"World\"\nvar count = 1\nfor kind, key, val in getopt():\n case kind\n of cmdLongOption:\n if key == \"name\": name = val\n if key == \"count\": count = parseInt(val)\n else: discard\n\nfor i in 0..<count:\n echo \"Xin chao, \", name, \"!\"", "note": ""}
{"topic": "Type hints / static typing nang cao", "language": "python", "code": "from typing import Optional, Union, Dict, List\n\ndef process(data: Dict[str, List[int]], flag: Optional[bool] = None) -> Union[int, str]:\n if flag:\n return \"co\"\n return sum(sum(v) for v in data.values())\n\nprint(process({\"a\": [1, 2, 3]}))", "note": ""}
{"topic": "Type hints / static typing nang cao (Nim von la statically typed)", "language": "nim", "code": "import std/tables\n\nproc process(data: Table[string, seq[int]], flag: bool = false): string =\n if flag:\n return \"co\"\n var total = 0\n for v in data.values:\n for x in v:\n total += x\n return $total\n\necho process({\"a\": @[1, 2, 3]}.toTable)", "note": ""}
{"topic": "Dataclass (object voi gia tri mac dinh)", "language": "python", "code": "from dataclasses import dataclass\n\n@dataclass\nclass User:\n name: str\n age: int = 18\n\nu = User(\"An\")\nprint(u)", "note": ""}
{"topic": "Object voi gia tri mac dinh (tuong duong dataclass)", "language": "nim", "code": "type\n User = object\n name: string\n age: int = 18\n\nlet u = User(name: \"An\")\necho u", "note": ""}
{"topic": "Property (getter/setter)", "language": "python", "code": "class Circle:\n def __init__(self, radius):\n self._radius = radius\n\n @property\n def area(self):\n return 3.14159 * self._radius ** 2\n\n @property\n def radius(self):\n return self._radius\n\n @radius.setter\n def radius(self, value):\n if value < 0:\n raise ValueError(\"Ban kinh phai duong\")\n self._radius = value\n\nc = Circle(5)\nprint(c.area)", "note": ""}
{"topic": "Property (getter/setter)", "language": "nim", "code": "type\n Circle = object\n radius: float\n\nproc area(c: Circle): float =\n return 3.14159 * c.radius * c.radius\n\nproc `radius=`(c: var Circle, value: float) =\n if value < 0:\n raise newException(ValueError, \"Ban kinh phai duong\")\n c.radius = value\n\nvar c = Circle(radius: 5.0)\necho c.area", "note": ""}
{"topic": "Abstract class / interface", "language": "python", "code": "from abc import ABC, abstractmethod\n\nclass Shape(ABC):\n @abstractmethod\n def area(self):\n pass\n\nclass Square(Shape):\n def __init__(self, side):\n self.side = side\n\n def area(self):\n return self.side ** 2\n\ns = Square(4)\nprint(s.area())", "note": ""}
{"topic": "Abstract class / interface", "language": "nim", "code": "type\n Shape = ref object of RootObj\n\nmethod area(s: Shape): float {.base.} =\n raise newException(CatchableError, \"Chua duoc cai dat\")\n\ntype\n Square = ref object of Shape\n side: float\n\nmethod area(s: Square): float =\n return s.side * s.side\n\nlet s = Square(side: 4.0)\necho s.area()", "note": ""}
{"topic": "Mixin", "language": "python", "code": "class SerializableMixin:\n def to_dict(self):\n return self.__dict__\n\nclass User(SerializableMixin):\n def __init__(self, name, age):\n self.name = name\n self.age = age\n\nu = User(\"An\", 25)\nprint(u.to_dict())", "note": ""}
{"topic": "Mixin (dung concept + template)", "language": "nim", "code": "type\n User = object\n name: string\n age: int\n\nproc toDict(u: User): string =\n return \"{name: \" & u.name & \", age: \" & $u.age & \"}\"\n\nlet u = User(name: \"An\", age: 25)\necho u.toDict()", "note": ""}
{"topic": "Memoization / caching (lru_cache)", "language": "python", "code": "from functools import lru_cache\n\n@lru_cache(maxsize=None)\ndef fib(n):\n if n <= 1:\n return n\n return fib(n - 1) + fib(n - 2)\n\nprint(fib(30))", "note": ""}
{"topic": "Memoization / caching tu cai dat", "language": "nim", "code": "import std/tables\n\nvar cache = initTable[int, int]()\n\nproc fib(n: int): int =\n if n <= 1:\n return n\n if cache.hasKey(n):\n return cache[n]\n let result = fib(n - 1) + fib(n - 2)\n cache[n] = result\n return result\n\necho fib(30)", "note": ""}
{"topic": "Generator expression", "language": "python", "code": "nums = (x * x for x in range(10))\nprint(sum(nums))", "note": ""}
{"topic": "Iterator (tuong duong generator expression)", "language": "nim", "code": "iterator squares(n: int): int =\n for x in 0..<n:\n yield x * x\n\nvar total = 0\nfor s in squares(10):\n total += s\necho total", "note": ""}
{"topic": "Context manager voi contextlib", "language": "python", "code": "from contextlib import contextmanager\n\n@contextmanager\ndef timer():\n print(\"Bat dau\")\n yield\n print(\"Ket thuc\")\n\nwith timer():\n print(\"Dang xu ly...\")", "note": ""}
{"topic": "Template lam context manager", "language": "nim", "code": "template timer(body: untyped) =\n echo \"Bat dau\"\n body\n echo \"Ket thuc\"\n\ntimer:\n echo \"Dang xu ly...\"", "note": ""}
{"topic": "Threading Lock / Mutex", "language": "python", "code": "import threading\n\nlock = threading.Lock()\ncounter = 0\n\ndef increment():\n global counter\n with lock:\n counter += 1\n\nthreads = [threading.Thread(target=increment) for _ in range(10)]\nfor t in threads:\n t.start()\nfor t in threads:\n t.join()\nprint(counter)", "note": ""}
{"topic": "Threading Lock / Mutex", "language": "nim", "code": "import std/locks\n\nvar lock: Lock\nvar counter = 0\ninitLock(lock)\n\nproc increment() {.thread.} =\n acquire(lock)\n inc counter\n release(lock)\n\nvar threads: array[10, Thread[void]]\nfor i in 0..<10:\n createThread(threads[i], increment)\njoinThreads(threads)\necho counter", "note": ""}
{"topic": "Queue giao tiep giua threads", "language": "python", "code": "import queue\nimport threading\n\nq = queue.Queue()\n\ndef producer():\n for i in range(5):\n q.put(i)\n\nt = threading.Thread(target=producer)\nt.start()\nt.join()\n\nwhile not q.empty():\n print(q.get())", "note": ""}
{"topic": "Channel giao tiep giua threads", "language": "nim", "code": "import std/[os, locks]\n\nvar chan: Channel[int]\nchan.open()\n\nproc producer() {.thread.} =\n for i in 0..<5:\n chan.send(i)\n\nvar t: Thread[void]\ncreateThread(t, producer)\njoinThread(t)\n\nfor i in 0..<5:\n echo chan.recv()", "note": ""}
{"topic": "Socket TCP client don gian", "language": "python", "code": "import socket\n\ndef send_message(host, port, msg):\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n s.connect((host, port))\n s.sendall(msg.encode())\n data = s.recv(1024)\n return data.decode()\n\n# print(send_message(\"localhost\", 8080, \"hello\"))", "note": ""}
{"topic": "Socket TCP client don gian", "language": "nim", "code": "import std/net\n\nproc sendMessage(host: string, port: int, msg: string): string =\n var socket = newSocket()\n socket.connect(host, Port(port))\n socket.send(msg)\n let data = socket.recvLine()\n socket.close()\n return data\n\n# echo sendMessage(\"localhost\", 8080, \"hello\")", "note": ""}
{"topic": "Regex nang cao (groups, replace)", "language": "python", "code": "import re\n\ntext = \"Ngay: 28/07/2026\"\nmatch = re.search(r\"(\\d+)/(\\d+)/(\\d+)\", text)\nif match:\n print(match.group(1), match.group(2), match.group(3))\n\nreplaced = re.sub(r\"\\d+\", \"X\", text)\nprint(replaced)", "note": ""}
{"topic": "Regex nang cao (groups, replace)", "language": "nim", "code": "import std/re\n\nlet text = \"Ngay: 28/07/2026\"\nvar matches: array[3, string]\nif text.match(re\"(\\d+)/(\\d+)/(\\d+)\", matches):\n echo matches[0], \" \", matches[1], \" \", matches[2]\n\nlet replaced = text.replace(re\"\\d+\", \"X\")\necho replaced", "note": ""}
{"topic": "Cay nhi phan - tim kiem gia tri", "language": "python", "code": "class Node:\n def __init__(self, value):\n self.value = value\n self.left = None\n self.right = None\n\ndef search(root, value):\n if root is None:\n return False\n if root.value == value:\n return True\n if value < root.value:\n return search(root.left, value)\n return search(root.right, value)", "note": ""}
{"topic": "Cay nhi phan - tim kiem gia tri", "language": "nim", "code": "type\n Node = ref object\n value: int\n left, right: Node\n\nproc search(root: Node, value: int): bool =\n if root == nil:\n return false\n if root.value == value:\n return true\n if value < root.value:\n return search(root.left, value)\n return search(root.right, value)", "note": ""}
{"topic": "Cay nhi phan - tinh chieu cao", "language": "python", "code": "def height(root):\n if root is None:\n return 0\n return 1 + max(height(root.left), height(root.right))", "note": ""}
{"topic": "Cay nhi phan - tinh chieu cao", "language": "nim", "code": "proc height(root: Node): int =\n if root == nil:\n return 0\n return 1 + max(height(root.left), height(root.right))", "note": ""}
{"topic": "Heap / hang doi uu tien (priority queue)", "language": "python", "code": "import heapq\n\nheap = []\nheapq.heappush(heap, 5)\nheapq.heappush(heap, 1)\nheapq.heappush(heap, 3)\nprint(heapq.heappop(heap))\nprint(heap)", "note": ""}
{"topic": "Heap / hang doi uu tien (priority queue)", "language": "nim", "code": "import std/heapqueue\n\nvar heap = initHeapQueue[int]()\nheap.push(5)\nheap.push(1)\nheap.push(3)\necho heap.pop()", "note": ""}
{"topic": "Trie (cay tien to)", "language": "python", "code": "class TrieNode:\n def __init__(self):\n self.children = {}\n self.is_end = False\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode()\n\n def insert(self, word):\n node = self.root\n for c in word:\n if c not in node.children:\n node.children[c] = TrieNode()\n node = node.children[c]\n node.is_end = True\n\n def search(self, word):\n node = self.root\n for c in word:\n if c not in node.children:\n return False\n node = node.children[c]\n return node.is_end\n\nt = Trie()\nt.insert(\"hello\")\nprint(t.search(\"hello\"))", "note": ""}
{"topic": "Trie (cay tien to)", "language": "nim", "code": "import std/tables\n\ntype\n TrieNode = ref object\n children: Table[char, TrieNode]\n isEnd: bool\n\n Trie = ref object\n root: TrieNode\n\nproc newTrie(): Trie =\n Trie(root: TrieNode(children: initTable[char, TrieNode]()))\n\nproc insert(t: Trie, word: string) =\n var node = t.root\n for c in word:\n if c notin node.children:\n node.children[c] = TrieNode(children: initTable[char, TrieNode]())\n node = node.children[c]\n node.isEnd = true\n\nproc search(t: Trie, word: string): bool =\n var node = t.root\n for c in word:\n if c notin node.children:\n return false\n node = node.children[c]\n return node.isEnd\n\nlet t = newTrie()\nt.insert(\"hello\")\necho t.search(\"hello\")", "note": ""}
{"topic": "Union-Find (Disjoint Set)", "language": "python", "code": "class UnionFind:\n def __init__(self, n):\n self.parent = list(range(n))\n\n def find(self, x):\n if self.parent[x] != x:\n self.parent[x] = self.find(self.parent[x])\n return self.parent[x]\n\n def union(self, x, y):\n rx, ry = self.find(x), self.find(y)\n if rx != ry:\n self.parent[rx] = ry\n\nuf = UnionFind(5)\nuf.union(0, 1)\nprint(uf.find(0) == uf.find(1))", "note": ""}
{"topic": "Union-Find (Disjoint Set)", "language": "nim", "code": "type\n UnionFind = object\n parent: seq[int]\n\nproc newUnionFind(n: int): UnionFind =\n result.parent = newSeq[int](n)\n for i in 0..<n:\n result.parent[i] = i\n\nproc find(uf: var UnionFind, x: int): int =\n if uf.parent[x] != x:\n uf.parent[x] = uf.find(uf.parent[x])\n return uf.parent[x]\n\nproc union(uf: var UnionFind, x, y: int) =\n let rx = uf.find(x)\n let ry = uf.find(y)\n if rx != ry:\n uf.parent[rx] = ry\n\nvar uf = newUnionFind(5)\nuf.union(0, 1)\necho uf.find(0) == uf.find(1)", "note": ""}
{"topic": "Dynamic Programming - bai toan cai tui (knapsack)", "language": "python", "code": "def knapsack(weights, values, capacity):\n n = len(weights)\n dp = [[0] * (capacity + 1) for _ in range(n + 1)]\n for i in range(1, n + 1):\n for w in range(capacity + 1):\n if weights[i - 1] <= w:\n dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])\n else:\n dp[i][w] = dp[i - 1][w]\n return dp[n][capacity]\n\nprint(knapsack([1, 3, 4, 5], [1, 4, 5, 7], 7))", "note": ""}
{"topic": "Dynamic Programming - bai toan cai tui (knapsack)", "language": "nim", "code": "proc knapsack(weights, values: seq[int], capacity: int): int =\n let n = weights.len\n var dp = newSeqWith(n + 1, newSeq[int](capacity + 1))\n for i in 1..n:\n for w in 0..capacity:\n if weights[i - 1] <= w:\n dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])\n else:\n dp[i][w] = dp[i - 1][w]\n return dp[n][capacity]\n\nimport std/sequtils\necho knapsack(@[1, 3, 4, 5], @[1, 4, 5, 7], 7)", "note": ""}
{"topic": "Dynamic Programming - day con chung dai nhat (LCS)", "language": "python", "code": "def lcs(a, b):\n m, n = len(a), len(b)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if a[i - 1] == b[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n return dp[m][n]\n\nprint(lcs(\"ABCBDAB\", \"BDCABA\"))", "note": ""}
{"topic": "Dynamic Programming - day con chung dai nhat (LCS)", "language": "nim", "code": "import std/sequtils\n\nproc lcs(a, b: string): int =\n let m = a.len\n let n = b.len\n var dp = newSeqWith(m + 1, newSeq[int](n + 1))\n for i in 1..m:\n for j in 1..n:\n if a[i - 1] == b[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n return dp[m][n]\n\necho lcs(\"ABCBDAB\", \"BDCABA\")", "note": ""}
{"topic": "Thuat toan Dijkstra tim duong di ngan nhat", "language": "python", "code": "import heapq\n\ndef dijkstra(graph, start):\n dist = {node: float(\"inf\") for node in graph}\n dist[start] = 0\n pq = [(0, start)]\n while pq:\n d, node = heapq.heappop(pq)\n if d > dist[node]:\n continue\n for neighbor, weight in graph[node]:\n new_dist = d + weight\n if new_dist < dist[neighbor]:\n dist[neighbor] = new_dist\n heapq.heappush(pq, (new_dist, neighbor))\n return dist\n\ngraph = {\"A\": [(\"B\", 1), (\"C\", 4)], \"B\": [(\"C\", 2)], \"C\": []}\nprint(dijkstra(graph, \"A\"))", "note": ""}
{"topic": "Thuat toan Dijkstra tim duong di ngan nhat", "language": "nim", "code": "import std/[tables, heapqueue]\n\nproc dijkstra(graph: Table[string, seq[(string, int)]], start: string): Table[string, int] =\n var dist = initTable[string, int]()\n for node in graph.keys:\n dist[node] = high(int)\n dist[start] = 0\n var pq = initHeapQueue[(int, string)]()\n pq.push((0, start))\n while pq.len > 0:\n let (d, node) = pq.pop()\n if d > dist[node]:\n continue\n for (neighbor, weight) in graph[node]:\n let newDist = d + weight\n if newDist < dist[neighbor]:\n dist[neighbor] = newDist\n pq.push((newDist, neighbor))\n return dist\n\nlet graph = {\"A\": @[(\"B\", 1), (\"C\", 4)], \"B\": @[(\"C\", 2)], \"C\": newSeq[(string, int)]()}.toTable\necho dijkstra(graph, \"A\")", "note": ""}
{"topic": "Sap xep topo (topological sort)", "language": "python", "code": "from collections import deque\n\ndef topo_sort(graph):\n in_degree = {node: 0 for node in graph}\n for node in graph:\n for neighbor in graph[node]:\n in_degree[neighbor] += 1\n queue = deque([n for n in in_degree if in_degree[n] == 0])\n order = []\n while queue:\n node = queue.popleft()\n order.append(node)\n for neighbor in graph[node]:\n in_degree[neighbor] -= 1\n if in_degree[neighbor] == 0:\n queue.append(neighbor)\n return order\n\ngraph = {\"A\": [\"B\", \"C\"], \"B\": [\"D\"], \"C\": [\"D\"], \"D\": []}\nprint(topo_sort(graph))", "note": ""}
{"topic": "Sap xep topo (topological sort)", "language": "nim", "code": "import std/[tables, deques]\n\nproc topoSort(graph: Table[string, seq[string]]): seq[string] =\n var inDegree = initTable[string, int]()\n for node in graph.keys:\n inDegree[node] = 0\n for node in graph.keys:\n for neighbor in graph[node]:\n inDegree[neighbor] += 1\n var queue = initDeque[string]()\n for node, deg in inDegree:\n if deg == 0:\n queue.addLast(node)\n var order: seq[string] = @[]\n while queue.len > 0:\n let node = queue.popFirst()\n order.add(node)\n for neighbor in graph[node]:\n inDegree[neighbor] -= 1\n if inDegree[neighbor] == 0:\n queue.addLast(neighbor)\n return order\n\nlet graph = {\"A\": @[\"B\", \"C\"], \"B\": @[\"D\"], \"C\": @[\"D\"], \"D\": newSeq[string]()}.toTable\necho topoSort(graph)", "note": ""}
{"topic": "Sliding window - tong lon nhat cua doan con", "language": "python", "code": "def max_sum_subarray(arr, k):\n max_sum = sum(arr[:k])\n window_sum = max_sum\n for i in range(k, len(arr)):\n window_sum += arr[i] - arr[i - k]\n max_sum = max(max_sum, window_sum)\n return max_sum\n\nprint(max_sum_subarray([1, 4, 2, 10, 2, 3, 1, 0, 20], 4))", "note": ""}
{"topic": "Sliding window - tong lon nhat cua doan con", "language": "nim", "code": "import std/sequtils\n\nproc maxSumSubarray(arr: seq[int], k: int): int =\n var maxSum = arr[0..<k].foldl(a + b)\n var windowSum = maxSum\n for i in k..<arr.len:\n windowSum += arr[i] - arr[i - k]\n maxSum = max(maxSum, windowSum)\n return maxSum\n\necho maxSumSubarray(@[1, 4, 2, 10, 2, 3, 1, 0, 20], 4)", "note": ""}
{"topic": "Two pointers - loai bo phan tu trung lap trong mang da sap xep", "language": "python", "code": "def remove_duplicates(arr):\n if not arr:\n return 0\n slow = 0\n for fast in range(1, len(arr)):\n if arr[fast] != arr[slow]:\n slow += 1\n arr[slow] = arr[fast]\n return slow + 1\n\narr = [1, 1, 2, 2, 3, 4, 4]\nprint(remove_duplicates(arr))", "note": ""}
{"topic": "Two pointers - loai bo phan tu trung lap trong mang da sap xep", "language": "nim", "code": "proc removeDuplicates(arr: var seq[int]): int =\n if arr.len == 0:\n return 0\n var slow = 0\n for fast in 1..<arr.len:\n if arr[fast] != arr[slow]:\n inc slow\n arr[slow] = arr[fast]\n return slow + 1\n\nvar arr = @[1, 1, 2, 2, 3, 4, 4]\necho removeDuplicates(arr)", "note": ""}
{"topic": "Bit manipulation - dem so bit 1", "language": "python", "code": "def count_set_bits(n):\n count = 0\n while n:\n count += n & 1\n n >>= 1\n return count\n\nprint(count_set_bits(29))", "note": ""}
{"topic": "Bit manipulation - dem so bit 1", "language": "nim", "code": "proc countSetBits(n: int): int =\n var n = n\n var count = 0\n while n > 0:\n count += n and 1\n n = n shr 1\n return count\n\necho countSetBits(29)", "note": ""}
{"topic": "Bit manipulation - XOR swap hai bien", "language": "python", "code": "a, b = 5, 10\na ^= b\nb ^= a\na ^= b\nprint(a, b)", "note": ""}
{"topic": "Bit manipulation - XOR swap hai bien", "language": "nim", "code": "var a = 5\nvar b = 10\na = a xor b\nb = a xor b\na = a xor b\necho a, \" \", b", "note": ""}
{"topic": "De quy - Thap Hanoi (Tower of Hanoi)", "language": "python", "code": "def hanoi(n, source, target, aux):\n if n == 1:\n print(f\"Di chuyen dia 1 tu {source} sang {target}\")\n return\n hanoi(n - 1, source, aux, target)\n print(f\"Di chuyen dia {n} tu {source} sang {target}\")\n hanoi(n - 1, aux, target, source)\n\nhanoi(3, \"A\", \"C\", \"B\")", "note": ""}
{"topic": "De quy - Thap Hanoi (Tower of Hanoi)", "language": "nim", "code": "proc hanoi(n: int, source, target, aux: string) =\n if n == 1:\n echo \"Di chuyen dia 1 tu \", source, \" sang \", target\n return\n hanoi(n - 1, source, aux, target)\n echo \"Di chuyen dia \", n, \" tu \", source, \" sang \", target\n hanoi(n - 1, aux, target, source)\n\nhanoi(3, \"A\", \"C\", \"B\")", "note": ""}
{"topic": "Fibonacci voi Dynamic Programming (bottom-up)", "language": "python", "code": "def fib_dp(n):\n if n <= 1:\n return n\n dp = [0] * (n + 1)\n dp[1] = 1\n for i in range(2, n + 1):\n dp[i] = dp[i - 1] + dp[i - 2]\n return dp[n]\n\nprint(fib_dp(30))", "note": ""}
{"topic": "Fibonacci voi Dynamic Programming (bottom-up)", "language": "nim", "code": "proc fibDp(n: int): int =\n if n <= 1:\n return n\n var dp = newSeq[int](n + 1)\n dp[1] = 1\n for i in 2..n:\n dp[i] = dp[i - 1] + dp[i - 2]\n return dp[n]\n\necho fibDp(30)", "note": ""}
{"topic": "Tim kiem chuoi con (naive string matching)", "language": "python", "code": "def find_substring(text, pattern):\n n, m = len(text), len(pattern)\n positions = []\n for i in range(n - m + 1):\n if text[i:i + m] == pattern:\n positions.append(i)\n return positions\n\nprint(find_substring(\"ababcababc\", \"abc\"))", "note": ""}
{"topic": "Tim kiem chuoi con (naive string matching)", "language": "nim", "code": "proc findSubstring(text, pattern: string): seq[int] =\n let n = text.len\n let m = pattern.len\n var positions: seq[int] = @[]\n for i in 0..n - m:\n if text[i..<i + m] == pattern:\n positions.add(i)\n return positions\n\necho findSubstring(\"ababcababc\", \"abc\")", "note": ""}
{"topic": "Doc cau hinh tu file .env", "language": "python", "code": "def load_env(path):\n config = {}\n with open(path) as f:\n for line in f:\n line = line.strip()\n if line and not line.startswith(\"#\") and \"=\" in line:\n key, value = line.split(\"=\", 1)\n config[key] = value\n return config\n\n# config = load_env(\".env\")", "note": ""}
{"topic": "Doc cau hinh tu file .env", "language": "nim", "code": "import std/[strutils, tables]\n\nproc loadEnv(path: string): Table[string, string] =\n var config = initTable[string, string]()\n for line in lines(path):\n let l = line.strip()\n if l.len > 0 and not l.startsWith(\"#\") and l.contains(\"=\"):\n let parts = l.split(\"=\", 1)\n config[parts[0]] = parts[1]\n return config\n\n# let config = loadEnv(\".env\")", "note": ""}
{"topic": "Design pattern Command", "language": "python", "code": "class Command:\n def execute(self):\n pass\n\nclass PrintCommand(Command):\n def __init__(self, msg):\n self.msg = msg\n\n def execute(self):\n print(self.msg)\n\ncommands = [PrintCommand(\"Xin chao\"), PrintCommand(\"Tam biet\")]\nfor cmd in commands:\n cmd.execute()", "note": ""}
{"topic": "Design pattern Command", "language": "nim", "code": "type\n Command = ref object of RootObj\n\nmethod execute(c: Command) {.base.} = discard\n\ntype\n PrintCommand = ref object of Command\n msg: string\n\nmethod execute(c: PrintCommand) =\n echo c.msg\n\nlet commands = @[PrintCommand(msg: \"Xin chao\"), PrintCommand(msg: \"Tam biet\")]\nfor cmd in commands:\n cmd.execute()", "note": ""}
{"topic": "Design pattern Builder", "language": "python", "code": "class Pizza:\n def __init__(self):\n self.toppings = []\n\n def add_topping(self, topping):\n self.toppings.append(topping)\n return self\n\n def __repr__(self):\n return f\"Pizza voi {self.toppings}\"\n\npizza = Pizza().add_topping(\"pho mai\").add_topping(\"nam\")\nprint(pizza)", "note": ""}
{"topic": "Design pattern Builder", "language": "nim", "code": "type\n Pizza = ref object\n toppings: seq[string]\n\nproc addTopping(p: Pizza, topping: string): Pizza =\n p.toppings.add(topping)\n return p\n\nproc `$`(p: Pizza): string =\n \"Pizza voi \" & $p.toppings\n\nvar pizza = Pizza(toppings: @[])\ndiscard pizza.addTopping(\"pho mai\").addTopping(\"nam\")\necho pizza", "note": ""}
{"topic": "Kiem tra du lieu dau vao (validate input)", "language": "python", "code": "def validate_user(data):\n errors = []\n if \"name\" not in data or not data[\"name\"]:\n errors.append(\"Thieu ten\")\n if \"age\" not in data or data[\"age\"] < 0:\n errors.append(\"Tuoi khong hop le\")\n return errors\n\nprint(validate_user({\"name\": \"\", \"age\": -1}))", "note": ""}
{"topic": "Kiem tra du lieu dau vao (validate input)", "language": "nim", "code": "import std/tables\n\nproc validateUser(data: Table[string, string]): seq[string] =\n var errors: seq[string] = @[]\n if not data.hasKey(\"name\") or data[\"name\"].len == 0:\n errors.add(\"Thieu ten\")\n if not data.hasKey(\"age\") or parseInt(data.getOrDefault(\"age\", \"-1\")) < 0:\n errors.add(\"Tuoi khong hop le\")\n return errors\n\necho validateUser({\"name\": \"\", \"age\": \"-1\"}.toTable)", "note": ""}
{"topic": "Rate limiter don gian", "language": "python", "code": "import time\n\nclass RateLimiter:\n def __init__(self, max_calls, period):\n self.max_calls = max_calls\n self.period = period\n self.calls = []\n\n def allow(self):\n now = time.time()\n self.calls = [c for c in self.calls if now - c < self.period]\n if len(self.calls) < self.max_calls:\n self.calls.append(now)\n return True\n return False\n\nlimiter = RateLimiter(3, 1)\nprint(limiter.allow())", "note": ""}
{"topic": "Rate limiter don gian", "language": "nim", "code": "import std/[times, deques]\n\ntype\n RateLimiter = object\n maxCalls: int\n period: float\n calls: Deque[float]\n\nproc allow(rl: var RateLimiter): bool =\n let now = epochTime()\n while rl.calls.len > 0 and now - rl.calls[0] >= rl.period:\n discard rl.calls.popFirst()\n if rl.calls.len < rl.maxCalls:\n rl.calls.addLast(now)\n return true\n return false\n\nvar limiter = RateLimiter(maxCalls: 3, period: 1.0, calls: initDeque[float]())\necho limiter.allow()", "note": ""}
{"topic": "LRU Cache tu cai dat", "language": "python", "code": "from collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.capacity = capacity\n self.cache = OrderedDict()\n\n def get(self, key):\n if key not in self.cache:\n return -1\n self.cache.move_to_end(key)\n return self.cache[key]\n\n def put(self, key, value):\n if key in self.cache:\n self.cache.move_to_end(key)\n self.cache[key] = value\n if len(self.cache) > self.capacity:\n self.cache.popitem(last=False)\n\nlru = LRUCache(2)\nlru.put(1, \"a\")\nlru.put(2, \"b\")\nlru.put(3, \"c\")\nprint(lru.get(1))", "note": ""}
{"topic": "LRU Cache tu cai dat", "language": "nim", "code": "import std/tables\n\ntype\n LRUCache = object\n capacity: int\n cache: OrderedTable[int, string]\n\nproc get(lru: var LRUCache, key: int): string =\n if not lru.cache.hasKey(key):\n return \"-1\"\n let value = lru.cache[key]\n lru.cache.del(key)\n lru.cache[key] = value\n return value\n\nproc put(lru: var LRUCache, key: int, value: string) =\n if lru.cache.hasKey(key):\n lru.cache.del(key)\n lru.cache[key] = value\n if lru.cache.len > lru.capacity:\n for k in lru.cache.keys:\n lru.cache.del(k)\n break\n\nvar lru = LRUCache(capacity: 2, cache: initOrderedTable[int, string]())\nlru.put(1, \"a\")\nlru.put(2, \"b\")\nlru.put(3, \"c\")\necho lru.get(1)", "note": ""}
{"topic": "Retry logic voi backoff", "language": "python", "code": "import time\n\ndef retry(func, max_attempts=3, delay=1):\n for attempt in range(max_attempts):\n try:\n return func()\n except Exception as e:\n print(f\"Loi lan {attempt + 1}: {e}\")\n time.sleep(delay * (attempt + 1))\n raise Exception(\"Da het so lan thu lai\")\n\ndef risky():\n raise ValueError(\"Loi gia lap\")\n\n# retry(risky)", "note": ""}
{"topic": "Retry logic voi backoff", "language": "nim", "code": "import std/os\n\nproc retry(fn: proc(), maxAttempts: int = 3, delay: int = 1) =\n for attempt in 0..<maxAttempts:\n try:\n fn()\n return\n except CatchableError as e:\n echo \"Loi lan \", attempt + 1, \": \", e.msg\n sleep(delay * (attempt + 1) * 1000)\n raise newException(CatchableError, \"Da het so lan thu lai\")\n\nproc risky() =\n raise newException(ValueError, \"Loi gia lap\")\n\n# retry(risky)", "note": ""}
{"topic": "Currying nang cao", "language": "python", "code": "def curry_add(a):\n def inner(b):\n def inner2(c):\n return a + b + c\n return inner2\n return inner\n\nprint(curry_add(1)(2)(3))", "note": ""}
{"topic": "Currying nang cao", "language": "nim", "code": "proc curryAdd(a: int): proc(b: int): proc(c: int): int =\n return proc(b: int): proc(c: int): int =\n return proc(c: int): int =\n return a + b + c\n\necho curryAdd(1)(2)(3)", "note": ""}
{"topic": "Functional pipeline (compose functions)", "language": "python", "code": "def compose(*functions):\n def composed(x):\n for fn in functions:\n x = fn(x)\n return x\n return composed\n\npipeline = compose(lambda x: x + 1, lambda x: x * 2, lambda x: x - 3)\nprint(pipeline(5))", "note": ""}
{"topic": "Functional pipeline (compose functions)", "language": "nim", "code": "proc compose(fns: seq[proc(x: int): int]): proc(x: int): int =\n return proc(x: int): int =\n var result = x\n for fn in fns:\n result = fn(result)\n return result\n\nlet pipeline = compose(@[\n proc(x: int): int = x + 1,\n proc(x: int): int = x * 2,\n proc(x: int): int = x - 3\n])\necho pipeline(5)", "note": ""}
{"topic": "Async HTTP - goi nhieu request dong thoi", "language": "python", "code": "import asyncio\n\nasync def fetch(url):\n await asyncio.sleep(0.5)\n return f\"Da tai xong {url}\"\n\nasync def main():\n urls = [\"url1\", \"url2\", \"url3\"]\n results = await asyncio.gather(*[fetch(u) for u in urls])\n print(results)\n\nasyncio.run(main())", "note": ""}
{"topic": "Async HTTP - goi nhieu request dong thoi", "language": "nim", "code": "import std/asyncdispatch\n\nproc fetch(url: string): Future[string] {.async.} =\n await sleepAsync(500)\n return \"Da tai xong \" & url\n\nproc main() {.async.} =\n let urls = @[\"url1\", \"url2\", \"url3\"]\n var futures: seq[Future[string]] = @[]\n for u in urls:\n futures.add(fetch(u))\n let results = await all(futures)\n echo results\n\nwaitFor main()", "note": ""}
{"topic": "Unit test voi mock", "language": "python", "code": "from unittest.mock import MagicMock\n\ndef send_email(mailer, to, msg):\n mailer.send(to, msg)\n return True\n\nmock_mailer = MagicMock()\nresult = send_email(mock_mailer, \"test@example.com\", \"Xin chao\")\nmock_mailer.send.assert_called_with(\"test@example.com\", \"Xin chao\")\nprint(result)", "note": ""}
{"topic": "Unit test co ban (Nim khong co mock built-in, dung stub thay the)", "language": "nim", "code": "type\n Mailer = object\n calls: seq[(string, string)]\n\nproc send(m: var Mailer, to, msg: string) =\n m.calls.add((to, msg))\n\nproc sendEmail(m: var Mailer, to, msg: string): bool =\n m.send(to, msg)\n return true\n\nvar mailer = Mailer(calls: @[])\nlet result = sendEmail(mailer, \"test@example.com\", \"Xin chao\")\necho mailer.calls\necho result", "note": ""}
{"topic": "Producer-Consumer pattern", "language": "python", "code": "import queue\nimport threading\n\nq = queue.Queue(maxsize=5)\n\ndef producer():\n for i in range(5):\n q.put(i)\n print(f\"San xuat: {i}\")\n\ndef consumer():\n for _ in range(5):\n item = q.get()\n print(f\"Tieu thu: {item}\")\n\nt1 = threading.Thread(target=producer)\nt2 = threading.Thread(target=consumer)\nt1.start(); t2.start()\nt1.join(); t2.join()", "note": ""}
{"topic": "Producer-Consumer pattern", "language": "nim", "code": "import std/os\n\nvar chan: Channel[int]\nchan.open(5)\n\nproc producer() {.thread.} =\n for i in 0..<5:\n chan.send(i)\n echo \"San xuat: \", i\n\nproc consumer() {.thread.} =\n for i in 0..<5:\n let item = chan.recv()\n echo \"Tieu thu: \", item\n\nvar t1, t2: Thread[void]\ncreateThread(t1, producer)\ncreateThread(t2, consumer)\njoinThread(t1)\njoinThread(t2)", "note": ""}
{"topic": "Design pattern Chain of Responsibility", "language": "python", "code": "class Handler:\n def __init__(self, next_handler=None):\n self.next_handler = next_handler\n\n def handle(self, request):\n if self.next_handler:\n return self.next_handler.handle(request)\n return \"Khong xu ly duoc\"\n\nclass AuthHandler(Handler):\n def handle(self, request):\n if request.get(\"authenticated\"):\n return super().handle(request)\n return \"Chua xac thuc\"\n\nh = AuthHandler()\nprint(h.handle({\"authenticated\": False}))", "note": ""}
{"topic": "Design pattern Chain of Responsibility", "language": "nim", "code": "type\n Handler = ref object of RootObj\n next: Handler\n\nmethod handle(h: Handler, authenticated: bool): string {.base.} =\n if h.next != nil:\n return h.next.handle(authenticated)\n return \"Khong xu ly duoc\"\n\ntype\n AuthHandler = ref object of Handler\n\nmethod handle(h: AuthHandler, authenticated: bool): string =\n if authenticated:\n if h.next != nil:\n return h.next.handle(authenticated)\n return \"Da xu ly\"\n return \"Chua xac thuc\"\n\nlet h = AuthHandler()\necho h.handle(false)", "note": ""}
{"topic": "State machine (may trang thai)", "language": "python", "code": "class TrafficLight:\n def __init__(self):\n self.state = \"red\"\n\n def next_state(self):\n transitions = {\"red\": \"green\", \"green\": \"yellow\", \"yellow\": \"red\"}\n self.state = transitions[self.state]\n return self.state\n\nlight = TrafficLight()\nfor _ in range(4):\n print(light.next_state())", "note": ""}
{"topic": "State machine (may trang thai)", "language": "nim", "code": "type\n LightState = enum\n Red, Green, Yellow\n\ntype\n TrafficLight = object\n state: LightState\n\nproc nextState(t: var TrafficLight): LightState =\n case t.state\n of Red: t.state = Green\n of Green: t.state = Yellow\n of Yellow: t.state = Red\n return t.state\n\nvar light = TrafficLight(state: Red)\nfor i in 0..<4:\n echo light.nextState()", "note": ""}
{"topic": "Pub/Sub (event-driven) don gian", "language": "python", "code": "class EventBus:\n def __init__(self):\n self.subscribers = {}\n\n def subscribe(self, event, fn):\n self.subscribers.setdefault(event, []).append(fn)\n\n def publish(self, event, data):\n for fn in self.subscribers.get(event, []):\n fn(data)\n\nbus = EventBus()\nbus.subscribe(\"user_created\", lambda data: print(f\"Da tao user: {data}\"))\nbus.publish(\"user_created\", \"An\")", "note": ""}
{"topic": "Pub/Sub (event-driven) don gian", "language": "nim", "code": "import std/tables\n\ntype\n EventBus = object\n subscribers: Table[string, seq[proc(data: string)]]\n\nproc subscribe(bus: var EventBus, event: string, fn: proc(data: string)) =\n if not bus.subscribers.hasKey(event):\n bus.subscribers[event] = @[]\n bus.subscribers[event].add(fn)\n\nproc publish(bus: EventBus, event: string, data: string) =\n if bus.subscribers.hasKey(event):\n for fn in bus.subscribers[event]:\n fn(data)\n\nvar bus = EventBus(subscribers: initTable[string, seq[proc(data: string)]]())\nbus.subscribe(\"user_created\", proc(data: string) = echo \"Da tao user: \", data)\nbus.publish(\"user_created\", \"An\")", "note": ""}
|