{"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": ""}