topic stringlengths 4 65 | language stringclasses 2
values | code stringlengths 20 791 | note stringclasses 1
value |
|---|---|---|---|
Tim phan tu trung lap trong mang | python | def find_duplicates(arr):
seen = set()
dups = set()
for x in arr:
if x in seen:
dups.add(x)
seen.add(x)
return list(dups)
print(find_duplicates([1, 2, 3, 2, 4, 1])) | |
Tim phan tu trung lap trong mang | nim | import std/sets
proc findDuplicates(arr: seq[int]): seq[int] =
var seen = initHashSet[int]()
var dups = initHashSet[int]()
for x in arr:
if x in seen:
dups.incl(x)
seen.incl(x)
return dups.toSeq()
echo findDuplicates(@[1, 2, 3, 2, 4, 1]) | |
Bai toan Two Sum | python | def two_sum(arr, target):
seen = {}
for i, v in enumerate(arr):
need = target - v
if need in seen:
return [seen[need], i]
seen[v] = i
return []
print(two_sum([2, 7, 11, 15], 9)) | |
Bai toan Two Sum | nim | import std/tables
proc twoSum(arr: seq[int], target: int): seq[int] =
var seen = initTable[int, int]()
for i, v in arr:
let need = target - v
if seen.hasKey(need):
return @[seen[need], i]
seen[v] = i
return @[]
echo twoSum(@[2, 7, 11, 15], 9) | |
Tinh BCNN (LCM) | python | def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
print(lcm(4, 6)) | |
Tinh BCNN (LCM) | nim | proc gcd(a, b: int): int =
var a = a
var b = b
while b != 0:
let t = b
b = a mod b
a = t
return a
proc lcm(a, b: int): int =
return a * b div gcd(a, b)
echo lcm(4, 6) | |
Phan tich thua so nguyen to | python | def prime_factors(n):
factors = []
d = 2
while d * d <= n:
while n % d == 0:
factors.append(d)
n //= d
d += 1
if n > 1:
factors.append(n)
return factors
print(prime_factors(360)) | |
Phan tich thua so nguyen to | nim | proc primeFactors(n: int): seq[int] =
var n = n
var factors: seq[int] = @[]
var d = 2
while d * d <= n:
while n mod d == 0:
factors.add(d)
n = n div d
inc d
if n > 1:
factors.add(n)
return factors
echo primeFactors(360) | |
Tinh luy thua (power function) | python | def power(base, exp):
if exp == 0:
return 1
return base * power(base, exp - 1)
print(power(2, 10)) | |
Tinh luy thua (power function) | nim | proc power(base, exp: int): int =
if exp == 0:
return 1
return base * power(base, exp - 1)
echo power(2, 10) | |
Tong cac chu so cua mot so | python | def sum_digits(n):
total = 0
n = abs(n)
while n > 0:
total += n % 10
n //= 10
return total
print(sum_digits(12345)) | |
Tong cac chu so cua mot so | nim | proc sumDigits(n: int): int =
var n = abs(n)
var total = 0
while n > 0:
total += n mod 10
n = n div 10
return total
echo sumDigits(12345) | |
Iterator/Generator (yield) | python | def counter(limit):
n = 0
while n < limit:
yield n
n += 1
for x in counter(5):
print(x) | |
Iterator/Generator (yield) | nim | iterator counter(limit: int): int =
var n = 0
while n < limit:
yield n
inc n
for x in counter(5):
echo x | |
Decorator (python) | python | def log_call(func):
def wrapper(*args, **kwargs):
print(f"Goi ham {func.__name__}")
return func(*args, **kwargs)
return wrapper
@log_call
def greet(name):
print(f"Xin chao, {name}")
greet("Nam") | |
Template (nim) - tuong duong decorator | nim | import std/macros
template logCall(body: untyped): untyped =
echo "Goi ham"
body
proc greet(name: string) =
logCall:
echo "Xin chao, ", name
greet("Nam") | |
Context manager (with) | python | class Timer:
def __enter__(self):
print("Bat dau")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("Ket thuc")
with Timer():
print("Dang xu ly...") | |
Defer (tuong duong context manager) | nim | proc doWork() =
echo "Bat dau"
defer: echo "Ket thuc"
echo "Dang xu ly..."
doWork() | |
Enum | python | from enum import Enum
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
print(Color.RED)
print(Color.RED.value) | |
Enum | nim | type
Color = enum
Red, Green, Blue
echo Red
echo ord(Red) | |
Ham generic (Generic function) | python | from typing import TypeVar, List
T = TypeVar("T")
def first_element(items: List[T]) -> T:
return items[0]
print(first_element([1, 2, 3]))
print(first_element(["a", "b", "c"])) | |
Ham generic (Generic function) | nim | proc firstElement[T](items: seq[T]): T =
return items[0]
echo firstElement(@[1, 2, 3])
echo firstElement(@["a", "b", "c"]) | |
Ngoai le tuy chinh (Custom exception) | python | class InsufficientFundsError(Exception):
pass
def withdraw(balance, amount):
if amount > balance:
raise InsufficientFundsError("Khong du tien")
return balance - amount
try:
withdraw(100, 200)
except InsufficientFundsError as e:
print(e) | |
Ngoai le tuy chinh (Custom exception) | nim | type
InsufficientFundsError = object of CatchableError
proc withdraw(balance, amount: int): int =
if amount > balance:
raise newException(InsufficientFundsError, "Khong du tien")
return balance - amount
try:
discard withdraw(100, 200)
except InsufficientFundsError as e:
echo e.msg | |
Regex co ban | python | import re
text = "So dien thoai: 0987654321"
match = re.search(r"\d{10}", text)
if match:
print(match.group()) | |
Regex co ban | nim | import std/re
let text = "So dien thoai: 0987654321"
let m = text.findAll(re"\d{10}")
echo m | |
Lam viec voi ngay thang (date/time) | python | from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S")) | |
Lam viec voi ngay thang (date/time) | nim | import std/times
let now = now()
echo now.format("yyyy-MM-dd HH:mm:ss") | |
So ngau nhien (random) | python | import random
print(random.randint(1, 100))
print(random.choice(["a", "b", "c"])) | |
So ngau nhien (random) | nim | import std/random
randomize()
echo rand(1..100)
echo sample(["a", "b", "c"]) | |
Doc tham so dong lenh (command line args) | python | import sys
for arg in sys.argv[1:]:
print(arg) | |
Doc tham so dong lenh (command line args) | nim | import std/os
for arg in commandLineParams():
echo arg | |
Lam viec voi JSON | python | import json
data = {"name": "Nam", "age": 25}
json_str = json.dumps(data)
print(json_str)
parsed = json.loads(json_str)
print(parsed["name"]) | |
Lam viec voi JSON | nim | import std/json
let data = %*{"name": "Nam", "age": 25}
let jsonStr = $data
echo jsonStr
let parsed = parseJson(jsonStr)
echo parsed["name"].getStr() | |
Ham reduce/fold | python | from functools import reduce
nums = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, nums, 0)
print(total) | |
Ham reduce/fold | nim | import std/sequtils
let nums = @[1, 2, 3, 4, 5]
let total = nums.foldl(a + b, 0)
echo total | |
Closure (ham dong) | python | def make_counter():
count = 0
def increment():
nonlocal count
count += 1
return count
return increment
counter = make_counter()
print(counter())
print(counter())
print(counter()) | |
Closure (ham dong) | nim | proc makeCounter(): proc(): int =
var count = 0
return proc(): int =
inc count
return count
let counter = makeCounter()
echo counter()
echo counter()
echo counter() | |
Sap xep voi key tuy chinh | python | people = [("An", 25), ("Binh", 20), ("Chi", 30)]
people.sort(key=lambda p: p[1])
print(people) | |
Sap xep voi key tuy chinh | nim | import std/algorithm
var people = @[("An", 25), ("Binh", 20), ("Chi", 30)]
people.sort(proc(a, b: (string, int)): int = cmp(a[1], b[1]))
echo people | |
Xu ly da luong co ban (threads) | python | import threading
def print_numbers():
for i in range(5):
print(i)
t = threading.Thread(target=print_numbers)
t.start()
t.join() | |
Xu ly da luong co ban (threads) | nim | import std/os
proc printNumbers() {.thread.} =
for i in 0..<5:
echo i
var t: Thread[void]
createThread(t, printNumbers)
joinThread(t) | |
Dinh dang chuoi (f-string) | python | name = "Nam"
age = 25
print(f"{name} nam nay {age} tuoi") | |
Dinh dang chuoi (strformat) | nim | import std/strformat
let name = "Nam"
let age = 25
echo &"{name} nam nay {age} tuoi" | |
Nap chong toan tu (operator overloading) | python | class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __repr__(self):
return f"Point({self.x}, {self.y})"
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1 + p2) | |
Nap chong toan tu (operator overloading) | nim | type
Point = object
x, y: int
proc `+`(a, b: Point): Point =
Point(x: a.x + b.x, y: a.y + b.y)
proc `$`(p: Point): string =
"Point(" & $p.x & ", " & $p.y & ")"
let p1 = Point(x: 1, y: 2)
let p2 = Point(x: 3, y: 4)
echo p1 + p2 | |
Named tuple | python | from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p.x, p.y) | |
Object variant (tuong duong named tuple) | nim | type
Point = object
x, y: int
let p = Point(x: 1, y: 2)
echo p.x, " ", p.y | |
Cat lat mang/chuoi (slicing) | python | arr = [1, 2, 3, 4, 5, 6]
print(arr[1:4])
print(arr[:3])
print(arr[3:]) | |
Cat lat mang/chuoi (slicing) | nim | let arr = @[1, 2, 3, 4, 5, 6]
echo arr[1..3]
echo arr[0..2]
echo arr[3..^1] | |
Kiem tra so chinh phuong va so hoan hao | python | import math
def is_perfect_square(n):
root = int(math.isqrt(n))
return root * root == n
def is_perfect_number(n):
total = sum(i for i in range(1, n) if n % i == 0)
return total == n
print(is_perfect_square(16))
print(is_perfect_number(28)) | |
Kiem tra so chinh phuong va so hoan hao | nim | import std/math
proc isPerfectSquare(n: int): bool =
let root = sqrt(n.float).int
return root * root == n
proc isPerfectNumber(n: int): bool =
var total = 0
for i in 1..<n:
if n mod i == 0:
total += i
return total == n
echo isPerfectSquare(16)
echo isPerfectNumber(28) | |
Day so tam giac Pascal (Pascal's triangle) | python | def pascals_triangle(n):
triangle = []
for i in range(n):
row = [1] * (i + 1)
for j in range(1, i):
row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
triangle.append(row)
return triangle
for row in pascals_triangle(5):
print(row) | |
Day so tam giac Pascal (Pascal's triangle) | nim | proc pascalsTriangle(n: int): seq[seq[int]] =
var triangle: seq[seq[int]] = @[]
for i in 0..<n:
var row = newSeq[int](i + 1)
row[0] = 1
row[i] = 1
for j in 1..<i:
row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
triangle.add(row)
return triangle
for row in pascalsTriangle(5):
echo... | |
Ma tran (2D array) - tao va duyet | python | matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
for val in row:
print(val, end=" ")
print() | |
Ma tran (2D array) - tao va duyet | nim | let matrix = @[@[1, 2, 3], @[4, 5, 6], @[7, 8, 9]]
for row in matrix:
for val in row:
stdout.write(val, " ")
echo ""
| |
Nhan ma tran (matrix multiplication) | python | def multiply(a, b):
rows_a, cols_a = len(a), len(a[0])
cols_b = len(b[0])
result = [[0] * cols_b for _ in range(rows_a)]
for i in range(rows_a):
for j in range(cols_b):
for k in range(cols_a):
result[i][j] += a[i][k] * b[k][j]
return result
a = [[1, 2], [3, 4]]
b... | |
Nhan ma tran (matrix multiplication) | nim | proc multiply(a, b: seq[seq[int]]): seq[seq[int]] =
let rowsA = a.len
let colsA = a[0].len
let colsB = b[0].len
var res = newSeqWith(rowsA, newSeq[int](colsB))
for i in 0..<rowsA:
for j in 0..<colsB:
for k in 0..<colsA:
res[i][j] += a[i][k] * b[k][j]
return res
import std/sequtils
let a =... | |
Chuyen doi so sang he nhi phan | python | def to_binary(n):
if n == 0:
return "0"
bits = ""
while n > 0:
bits = str(n % 2) + bits
n //= 2
return bits
print(to_binary(42))
print(bin(42)) | |
Chuyen doi so sang he nhi phan | nim | proc toBinary(n: int): string =
if n == 0:
return "0"
var n = n
var bits = ""
while n > 0:
bits = $(n mod 2) & bits
n = n div 2
return bits
echo toBinary(42)
echo toBin(42, 8) | |
HTTP GET request | python | import urllib.request
with urllib.request.urlopen("https://api.github.com") as response:
data = response.read()
print(data[:100]) | |
HTTP GET request | nim | import std/httpclient
let client = newHttpClient()
let response = client.getContent("https://api.github.com")
echo response[0..100] | |
HTTP POST request | python | import urllib.request
import json
data = json.dumps({"key": "value"}).encode()
req = urllib.request.Request("https://httpbin.org/post", data=data, method="POST")
with urllib.request.urlopen(req) as response:
print(response.read()) | |
HTTP POST request | nim | import std/httpclient
let client = newHttpClient()
let response = client.postContent("https://httpbin.org/post", body = """{"key":"value"}""")
echo response | |
Lam viec voi SQLite (tao bang, insert, query) | python | import sqlite3
conn = sqlite3.connect(":memory:")
cur = conn.cursor()
cur.execute("CREATE TABLE users (id INTEGER, name TEXT)")
cur.execute("INSERT INTO users VALUES (1, 'An')")
conn.commit()
cur.execute("SELECT * FROM users")
print(cur.fetchall())
conn.close() | |
Lam viec voi SQLite (tao bang, insert, query) | nim | import std/db_sqlite
let db = open(":memory:", "", "", "")
db.exec(sql"CREATE TABLE users (id INTEGER, name TEXT)")
db.exec(sql"INSERT INTO users VALUES (?, ?)", 1, "An")
for row in db.rows(sql"SELECT * FROM users"):
echo row
db.close() | |
Async/await co ban | python | import asyncio
async def say_hello():
await asyncio.sleep(1)
print("Xin chao!")
asyncio.run(say_hello()) | |
Async/await co ban | nim | import std/asyncdispatch
proc sayHello() {.async.} =
await sleepAsync(1000)
echo "Xin chao!"
waitFor sayHello() | |
Unit test co ban | python | import unittest
def add(a, b):
return a + b
class TestAdd(unittest.TestCase):
def test_add(self):
self.assertEqual(add(2, 3), 5)
if __name__ == "__main__":
unittest.main() | |
Unit test co ban | nim | import std/unittest
proc add(a, b: int): int = a + b
suite "test add":
test "cong hai so":
check add(2, 3) == 5 | |
Design pattern Singleton | python | class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
a = Singleton()
b = Singleton()
print(a is b) | |
Design pattern Singleton | nim | var instance {.threadvar.}: ref int
proc getInstance(): ref int =
if instance.isNil:
instance = new(int)
instance[] = 42
return instance
let a = getInstance()
let b = getInstance()
echo a == b | |
Design pattern Factory | python | class Dog:
def speak(self):
return "Gau gau"
class Cat:
def speak(self):
return "Meo meo"
def animal_factory(kind):
if kind == "dog":
return Dog()
return Cat()
a = animal_factory("dog")
print(a.speak()) | |
Design pattern Factory | nim | type
Animal = ref object of RootObj
Dog = ref object of Animal
Cat = ref object of Animal
method speak(a: Animal): string {.base.} = ""
method speak(d: Dog): string = "Gau gau"
method speak(c: Cat): string = "Meo meo"
proc animalFactory(kind: string): Animal =
if kind == "dog":
return Dog()
return Cat(... | |
Design pattern Observer | python | class Subject:
def __init__(self):
self.observers = []
def subscribe(self, fn):
self.observers.append(fn)
def notify(self, msg):
for fn in self.observers:
fn(msg)
def logger(msg):
print(f"Log: {msg}")
s = Subject()
s.subscribe(logger)
s.notify("su kien xay ra") | |
Design pattern Observer | nim | type
Subject = object
observers: seq[proc(msg: string)]
proc subscribe(s: var Subject, fn: proc(msg: string)) =
s.observers.add(fn)
proc notify(s: Subject, msg: string) =
for fn in s.observers:
fn(msg)
proc logger(msg: string) =
echo "Log: ", msg
var s = Subject()
s.subscribe(logger)
s.notify("su ki... | |
Design pattern Strategy | python | def add_strategy(a, b):
return a + b
def mul_strategy(a, b):
return a * b
class Calculator:
def __init__(self, strategy):
self.strategy = strategy
def execute(self, a, b):
return self.strategy(a, b)
calc = Calculator(add_strategy)
print(calc.execute(3, 4)) | |
Design pattern Strategy | nim | type
Calculator = object
strategy: proc(a, b: int): int
proc execute(c: Calculator, a, b: int): int =
return c.strategy(a, b)
let addStrategy = proc(a, b: int): int = a + b
let calc = Calculator(strategy: addStrategy)
echo calc.execute(3, 4) | |
Xu ly song song (multiprocessing) | python | from multiprocessing import Pool
def square(x):
return x * x
if __name__ == "__main__":
with Pool(4) as p:
print(p.map(square, [1, 2, 3, 4, 5])) | |
Xu ly song song (threads trong Nim) | nim | import std/[os, threadpool]
proc square(x: int): int =
return x * x
var results: seq[FlowVar[int]] = @[]
for i in 1..5:
results.add(spawn square(i))
for r in results:
echo ^r | |
He thong ngoai le tuy chinh (exception hierarchy) | python | class AppError(Exception):
pass
class NotFoundError(AppError):
pass
class ValidationError(AppError):
pass
try:
raise NotFoundError("Khong tim thay")
except AppError as e:
print(f"Loi ung dung: {e}") | |
He thong ngoai le tuy chinh (exception hierarchy) | nim | type
AppError = object of CatchableError
NotFoundError = object of AppError
ValidationError = object of AppError
try:
raise newException(NotFoundError, "Khong tim thay")
except AppError as e:
echo "Loi ung dung: ", e.msg | |
Serialization/deserialization (pickle) | python | import pickle
data = {"name": "An", "age": 25}
serialized = pickle.dumps(data)
restored = pickle.loads(serialized)
print(restored) | |
Serialization/deserialization (JSON) | nim | import std/json
let data = %*{"name": "An", "age": 25}
let serialized = $data
let restored = parseJson(serialized)
echo restored | |
Xu ly file CSV | python | import csv
with open("data.csv", "w", newline="") as f:
writer = csv.writer(f)
writer.writerow(["ten", "tuoi"])
writer.writerow(["An", 25])
with open("data.csv", "r") as f:
reader = csv.reader(f)
for row in reader:
print(row) | |
Xu ly file CSV | nim | import std/[parsecsv, streams]
var f = newFileStream("data.csv", fmWrite)
f.writeLine("ten,tuoi")
f.writeLine("An,25")
f.close()
var parser: CsvParser
parser.open("data.csv")
while parser.readRow():
echo parser.row
parser.close() | |
Xu ly file XML | python | import xml.etree.ElementTree as ET
root = ET.Element("root")
child = ET.SubElement(root, "user")
child.set("name", "An")
tree = ET.ElementTree(root)
print(ET.tostring(root)) | |
Xu ly file XML | nim | import std/xmltree
var root = newElement("root")
var child = newElement("user")
child.attrs = {"name": "An"}.toXmlAttributes
root.add(child)
echo $root | |
Ghi log (logging) | python | import logging
logging.basicConfig(level=logging.INFO)
logging.info("Ung dung da khoi dong")
logging.warning("Day la canh bao")
logging.error("Da xay ra loi") | |
Ghi log (logging) | nim | import std/logging
var logger = newConsoleLogger()
addHandler(logger)
info("Ung dung da khoi dong")
warn("Day la canh bao")
error("Da xay ra loi") | |
Bien moi truong (environment variables) | python | import os
os.environ["MY_VAR"] = "hello"
print(os.environ.get("MY_VAR"))
print(os.getenv("PATH_KHONG_TON_TAI", "gia tri mac dinh")) | |
Bien moi truong (environment variables) | nim | import std/os
putEnv("MY_VAR", "hello")
echo getEnv("MY_VAR")
echo getEnv("PATH_KHONG_TON_TAI", "gia tri mac dinh") | |
Argparse nang cao (command line parser) | python | import argparse
parser = argparse.ArgumentParser(description="Vi du argparse")
parser.add_argument("--name", type=str, default="World")
parser.add_argument("--count", type=int, default=1)
args = parser.parse_args()
for _ in range(args.count):
print(f"Xin chao, {args.name}!") | |
Argparse nang cao (command line parser) | nim | import std/parseopt
var name = "World"
var count = 1
for kind, key, val in getopt():
case kind
of cmdLongOption:
if key == "name": name = val
if key == "count": count = parseInt(val)
else: discard
for i in 0..<count:
echo "Xin chao, ", name, "!" | |
Type hints / static typing nang cao | python | from typing import Optional, Union, Dict, List
def process(data: Dict[str, List[int]], flag: Optional[bool] = None) -> Union[int, str]:
if flag:
return "co"
return sum(sum(v) for v in data.values())
print(process({"a": [1, 2, 3]})) | |
Type hints / static typing nang cao (Nim von la statically typed) | nim | import std/tables
proc process(data: Table[string, seq[int]], flag: bool = false): string =
if flag:
return "co"
var total = 0
for v in data.values:
for x in v:
total += x
return $total
echo process({"a": @[1, 2, 3]}.toTable) | |
Dataclass (object voi gia tri mac dinh) | python | from dataclasses import dataclass
@dataclass
class User:
name: str
age: int = 18
u = User("An")
print(u) | |
Object voi gia tri mac dinh (tuong duong dataclass) | nim | type
User = object
name: string
age: int = 18
let u = User(name: "An")
echo u | |
Property (getter/setter) | python | class Circle:
def __init__(self, radius):
self._radius = radius
@property
def area(self):
return 3.14159 * self._radius ** 2
@property
def radius(self):
return self._radius
@radius.setter
def radius(self, value):
if value < 0:
raise ValueError("... | |
Property (getter/setter) | nim | type
Circle = object
radius: float
proc area(c: Circle): float =
return 3.14159 * c.radius * c.radius
proc `radius=`(c: var Circle, value: float) =
if value < 0:
raise newException(ValueError, "Ban kinh phai duong")
c.radius = value
var c = Circle(radius: 5.0)
echo c.area |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.