Hugging Face's logo

Datasets:
bobbydeveloper2014
/
mega-nim-python-code

Modalities:
Text
Formats:
json
Size:
< 1K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
bobbydeveloper2014 commited on
Commit
d50e007
·
verified ·
1 Parent(s): 1466c09

Add nim_python_code_dataset_mega.jsonl

Browse files
Files changed (1) hide show
  1. nim_python_code_dataset_mega.jsonl +280 -0
nim_python_code_dataset_mega.jsonl ADDED
@@ -0,0 +1,280 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {"topic": "Hello World", "language": "python", "code": "print(\"Hello, World!\")", "note": ""}
2
+ {"topic": "Hello World", "language": "nim", "code": "echo \"Hello, World!\"", "note": ""}
3
+ {"topic": "Bien so va kieu du lieu", "language": "python", "code": "x = 10\ny = 3.14\nname = \"Python\"\nprint(x, y, name)", "note": ""}
4
+ {"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": ""}
5
+ {"topic": "Vong lap for", "language": "python", "code": "for i in range(5):\n print(i)", "note": ""}
6
+ {"topic": "Vong lap for", "language": "nim", "code": "for i in 0..<5:\n echo i", "note": ""}
7
+ {"topic": "Vong lap while", "language": "python", "code": "i = 0\nwhile i < 5:\n print(i)\n i += 1", "note": ""}
8
+ {"topic": "Vong lap while", "language": "nim", "code": "var i = 0\nwhile i < 5:\n echo i\n inc i", "note": ""}
9
+ {"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": ""}
10
+ {"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": ""}
11
+ {"topic": "Ham co ban", "language": "python", "code": "def add(a, b):\n return a + b\n\nprint(add(3, 4))", "note": ""}
12
+ {"topic": "Ham co ban", "language": "nim", "code": "proc add(a, b: int): int =\n return a + b\n\necho add(3, 4)", "note": ""}
13
+ {"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": ""}
14
+ {"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": ""}
15
+ {"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": ""}
16
+ {"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": ""}
17
+ {"topic": "Danh sach (list/array)", "language": "python", "code": "arr = [1, 2, 3, 4, 5]\nfor x in arr:\n print(x)", "note": ""}
18
+ {"topic": "Danh sach (list/array)", "language": "nim", "code": "var arr = @[1, 2, 3, 4, 5]\nfor x in arr:\n echo x", "note": ""}
19
+ {"topic": "Dictionary/Table (key-value)", "language": "python", "code": "d = {\"a\": 1, \"b\": 2}\nprint(d[\"a\"])", "note": ""}
20
+ {"topic": "Dictionary/Table (key-value)", "language": "nim", "code": "import tables\nvar t = {\"a\": 1, \"b\": 2}.toTable\necho t[\"a\"]", "note": ""}
21
+ {"topic": "Tap hop (set)", "language": "python", "code": "s = {1, 2, 3}\nprint(s)", "note": ""}
22
+ {"topic": "Tap hop (set)", "language": "nim", "code": "var s = {1, 2, 3}\necho s", "note": ""}
23
+ {"topic": "Tuple", "language": "python", "code": "t = (1, \"hello\")\nprint(t[0], t[1])", "note": ""}
24
+ {"topic": "Tuple", "language": "nim", "code": "let t = (1, \"hello\")\necho t[0], \" \", t[1]", "note": ""}
25
+ {"topic": "Thao tac chuoi (string)", "language": "python", "code": "s = \"Hello, Python!\"\nprint(s.upper())\nprint(len(s))", "note": ""}
26
+ {"topic": "Thao tac chuoi (string)", "language": "nim", "code": "import std/strutils\nlet s = \"Hello, Nim!\"\necho s.toUpperAscii()\necho s.len", "note": ""}
27
+ {"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": ""}
28
+ {"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": ""}
29
+ {"topic": "Xu ly loi (exception)", "language": "python", "code": "try:\n raise ValueError(\"loi\")\nexcept ValueError as e:\n print(\"Bat loi:\", e)", "note": ""}
30
+ {"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": ""}
31
+ {"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": ""}
32
+ {"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": ""}
33
+ {"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": ""}
34
+ {"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": ""}
35
+ {"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": ""}
36
+ {"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": ""}
37
+ {"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": ""}
38
+ {"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": ""}
39
+ {"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": ""}
40
+ {"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": ""}
41
+ {"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": ""}
42
+ {"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": ""}
43
+ {"topic": "List/seq comprehension", "language": "python", "code": "squares = [x * x for x in range(1, 6)]\nprint(squares)", "note": ""}
44
+ {"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": ""}
45
+ {"topic": "Ham lambda", "language": "python", "code": "add = lambda a, b: a + b\nprint(add(3, 4))", "note": ""}
46
+ {"topic": "Ham lambda", "language": "nim", "code": "let add = proc(a, b: int): int = a + b\necho add(3, 4)", "note": ""}
47
+ {"topic": "Module/import co ban", "language": "python", "code": "import math\n\nprint(math.sqrt(16))\nprint(math.pow(2, 10))", "note": ""}
48
+ {"topic": "Module/import co ban", "language": "nim", "code": "import std/math\n\necho sqrt(16.0)\necho pow(2.0, 10.0)", "note": ""}
49
+ {"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": ""}
50
+ {"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": ""}
51
+ {"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": ""}
52
+ {"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": ""}
53
+ {"topic": "Doi cho hai bien (swap)", "language": "python", "code": "a, b = 5, 10\na, b = b, a\nprint(a, b)", "note": ""}
54
+ {"topic": "Doi cho hai bien (swap)", "language": "nim", "code": "var a = 5\nvar b = 10\nswap(a, b)\necho a, \" \", b", "note": ""}
55
+ {"topic": "Doc du lieu tu ban phim", "language": "python", "code": "name = input(\"Nhap ten cua ban: \")\nprint(f\"Xin chao, {name}!\")", "note": ""}
56
+ {"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": ""}
57
+ {"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": ""}
58
+ {"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": ""}
59
+ {"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": ""}
60
+ {"topic": "Doc file theo tung dong", "language": "nim", "code": "for line in lines(\"test.txt\"):\n echo line", "note": ""}
61
+ {"topic": "Ngan xep (Stack)", "language": "python", "code": "stack = []\nstack.append(1)\nstack.append(2)\nstack.append(3)\nprint(stack.pop())\nprint(stack)", "note": ""}
62
+ {"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": ""}
63
+ {"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": ""}
64
+ {"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": ""}
65
+ {"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": ""}
66
+ {"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": ""}
67
+ {"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": ""}
68
+ {"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": ""}
69
+ {"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": ""}
70
+ {"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": ""}
71
+ {"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": ""}
72
+ {"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": ""}
73
+ {"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": ""}
74
+ {"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": ""}
75
+ {"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": ""}
76
+ {"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": ""}
77
+ {"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": ""}
78
+ {"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": ""}
79
+ {"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": ""}
80
+ {"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": ""}
81
+ {"topic": "Dao nguoc chuoi", "language": "python", "code": "s = \"Hello, Python!\"\nprint(s[::-1])", "note": ""}
82
+ {"topic": "Dao nguoc chuoi", "language": "nim", "code": "import std/algorithm\n\nvar s = \"Hello, Nim!\"\necho s.reversed()", "note": ""}
83
+ {"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": ""}
84
+ {"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": ""}
85
+ {"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": ""}
86
+ {"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": ""}
87
+ {"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": ""}
88
+ {"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": ""}
89
+ {"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": ""}
90
+ {"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": ""}
91
+ {"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": ""}
92
+ {"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": ""}
93
+ {"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": ""}
94
+ {"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": ""}
95
+ {"topic": "Tong cac phan tu trong mang", "language": "python", "code": "arr = [1, 2, 3, 4, 5]\nprint(sum(arr))", "note": ""}
96
+ {"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": ""}
97
+ {"topic": "Dao nguoc mang", "language": "python", "code": "arr = [1, 2, 3, 4, 5]\nprint(arr[::-1])", "note": ""}
98
+ {"topic": "Dao nguoc mang", "language": "nim", "code": "import std/algorithm\n\nvar arr = @[1, 2, 3, 4, 5]\necho arr.reversed()", "note": ""}
99
+ {"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": ""}
100
+ {"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": ""}
101
+ {"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": ""}
102
+ {"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": ""}
103
+ {"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": ""}
104
+ {"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": ""}
105
+ {"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": ""}
106
+ {"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": ""}
107
+ {"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": ""}
108
+ {"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": ""}
109
+ {"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": ""}
110
+ {"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": ""}
111
+ {"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": ""}
112
+ {"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": ""}
113
+ {"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": ""}
114
+ {"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": ""}
115
+ {"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": ""}
116
+ {"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": ""}
117
+ {"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": ""}
118
+ {"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": ""}
119
+ {"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": ""}
120
+ {"topic": "Enum", "language": "nim", "code": "type\n Color = enum\n Red, Green, Blue\n\necho Red\necho ord(Red)", "note": ""}
121
+ {"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": ""}
122
+ {"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": ""}
123
+ {"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": ""}
124
+ {"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": ""}
125
+ {"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": ""}
126
+ {"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": ""}
127
+ {"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": ""}
128
+ {"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": ""}
129
+ {"topic": "So ngau nhien (random)", "language": "python", "code": "import random\n\nprint(random.randint(1, 100))\nprint(random.choice([\"a\", \"b\", \"c\"]))", "note": ""}
130
+ {"topic": "So ngau nhien (random)", "language": "nim", "code": "import std/random\n\nrandomize()\necho rand(1..100)\necho sample([\"a\", \"b\", \"c\"])", "note": ""}
131
+ {"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": ""}
132
+ {"topic": "Doc tham so dong lenh (command line args)", "language": "nim", "code": "import std/os\n\nfor arg in commandLineParams():\n echo arg", "note": ""}
133
+ {"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": ""}
134
+ {"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": ""}
135
+ {"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": ""}
136
+ {"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": ""}
137
+ {"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": ""}
138
+ {"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": ""}
139
+ {"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": ""}
140
+ {"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": ""}
141
+ {"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": ""}
142
+ {"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": ""}
143
+ {"topic": "Dinh dang chuoi (f-string)", "language": "python", "code": "name = \"Nam\"\nage = 25\nprint(f\"{name} nam nay {age} tuoi\")", "note": ""}
144
+ {"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": ""}
145
+ {"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": ""}
146
+ {"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": ""}
147
+ {"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": ""}
148
+ {"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": ""}
149
+ {"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": ""}
150
+ {"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": ""}
151
+ {"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": ""}
152
+ {"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": ""}
153
+ {"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": ""}
154
+ {"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": ""}
155
+ {"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": ""}
156
+ {"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": ""}
157
+ {"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": ""}
158
+ {"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": ""}
159
+ {"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": ""}
160
+ {"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": ""}
161
+ {"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": ""}
162
+ {"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": ""}
163
+ {"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": ""}
164
+ {"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": ""}
165
+ {"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": ""}
166
+ {"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": ""}
167
+ {"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": ""}
168
+ {"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": ""}
169
+ {"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": ""}
170
+ {"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": ""}
171
+ {"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": ""}
172
+ {"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": ""}
173
+ {"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": ""}
174
+ {"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": ""}
175
+ {"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": ""}
176
+ {"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": ""}
177
+ {"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": ""}
178
+ {"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": ""}
179
+ {"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": ""}
180
+ {"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": ""}
181
+ {"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": ""}
182
+ {"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": ""}
183
+ {"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": ""}
184
+ {"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": ""}
185
+ {"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": ""}
186
+ {"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": ""}
187
+ {"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": ""}
188
+ {"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": ""}
189
+ {"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": ""}
190
+ {"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": ""}
191
+ {"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": ""}
192
+ {"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": ""}
193
+ {"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": ""}
194
+ {"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": ""}
195
+ {"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": ""}
196
+ {"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": ""}
197
+ {"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": ""}
198
+ {"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": ""}
199
+ {"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": ""}
200
+ {"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": ""}
201
+ {"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": ""}
202
+ {"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": ""}
203
+ {"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": ""}
204
+ {"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": ""}
205
+ {"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": ""}
206
+ {"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": ""}
207
+ {"topic": "Generator expression", "language": "python", "code": "nums = (x * x for x in range(10))\nprint(sum(nums))", "note": ""}
208
+ {"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": ""}
209
+ {"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": ""}
210
+ {"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": ""}
211
+ {"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": ""}
212
+ {"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": ""}
213
+ {"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": ""}
214
+ {"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": ""}
215
+ {"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": ""}
216
+ {"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": ""}
217
+ {"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": ""}
218
+ {"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": ""}
219
+ {"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": ""}
220
+ {"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": ""}
221
+ {"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": ""}
222
+ {"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": ""}
223
+ {"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": ""}
224
+ {"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": ""}
225
+ {"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": ""}
226
+ {"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": ""}
227
+ {"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": ""}
228
+ {"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": ""}
229
+ {"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": ""}
230
+ {"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": ""}
231
+ {"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": ""}
232
+ {"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": ""}
233
+ {"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": ""}
234
+ {"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": ""}
235
+ {"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": ""}
236
+ {"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": ""}
237
+ {"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": ""}
238
+ {"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": ""}
239
+ {"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": ""}
240
+ {"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": ""}
241
+ {"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": ""}
242
+ {"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": ""}
243
+ {"topic": "Bit manipulation - XOR swap hai bien", "language": "python", "code": "a, b = 5, 10\na ^= b\nb ^= a\na ^= b\nprint(a, b)", "note": ""}
244
+ {"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": ""}
245
+ {"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": ""}
246
+ {"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": ""}
247
+ {"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": ""}
248
+ {"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": ""}
249
+ {"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": ""}
250
+ {"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": ""}
251
+ {"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": ""}
252
+ {"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": ""}
253
+ {"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": ""}
254
+ {"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": ""}
255
+ {"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": ""}
256
+ {"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": ""}
257
+ {"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": ""}
258
+ {"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": ""}
259
+ {"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": ""}
260
+ {"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": ""}
261
+ {"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": ""}
262
+ {"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": ""}
263
+ {"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": ""}
264
+ {"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": ""}
265
+ {"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": ""}
266
+ {"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": ""}
267
+ {"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": ""}
268
+ {"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": ""}
269
+ {"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": ""}
270
+ {"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": ""}
271
+ {"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": ""}
272
+ {"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": ""}
273
+ {"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": ""}
274
+ {"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": ""}
275
+ {"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": ""}
276
+ {"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": ""}
277
+ {"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": ""}
278
+ {"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": ""}
279
+ {"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": ""}
280
+ {"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": ""}