Atlassian 2026 面试全流程攻略：OA → Phone → VO 真实面经汇总

class CarType(Enum):
BIG = 1
MEDIUM = 2
SMALL = 3

class ParkingTicket:
"""停车票，记录车辆停放信息"""
def __init__(self, ticket_id: int, car_type: CarType,
floor: int, spot: int):
self.ticket_id = ticket_id
self.car_type = car_type
self.floor = floor
self.spot = spot
self.timestamp = time.time()

class ParkingFloor:
"""单层停车场"""
def __init__(self, floor_id: int, capacity: Dict[CarType, int]):
self.floor_id = floor_id
self.capacity = capacity # {CarType: 数量}
self.available = dict(capacity)
self.ticket_counter = 0
self.lock = threading.Lock()

def park(self, car_type: CarType) -> Optional[ParkingTicket]:
"""尝试停车，找到最近的空位"""
with self.lock:
if self.available.get(car_type, 0) > 0:
self.available[car_type] -= 1
self.ticket_counter += 1
return ParkingTicket(
ticket_id=self.ticket_counter,
car_type=car_type,
floor=self.floor_id,
spot=self.ticket_counter
)
return None

def leave(self, car_type: CarType) -> bool:
"""释放车位"""
with self.lock:
if car_type in self.available:
self.available[car_type] += 1
return True
return False

class ParkingLot:
"""多层停车场"""
# 允许停放的车型层次：SMALL 可以停在大车位，但不能反过来
COMPATIBLE_SLOTS = {
CarType.BIG: [CarType.BIG],
CarType.MEDIUM: [CarType.MEDIUM, CarType.BIG],
CarType.SMALL: [CarType.SMALL, CarType.MEDIUM, CarType.BIG],
}

def __init__(self, floors: List[ParkingFloor]):
self.floors = floors
self.lock = threading.Lock()

def park(self, car_type: CarType, entry_floor: int = 0
) -> Optional[ParkingTicket]:
"""
停放车辆，优先选择入口楼层，然后选择相邻楼层
"""
with self.lock:
# 优先入口楼层
for floor in self.floors:
if floor.floor_id == entry_floor:
for slot_type in self.COMPATIBLE_SLOTS[car_type]:
ticket = floor.park(slot_type)
if ticket:
return ticket

# 搜索相邻楼层
for offset in range(1, max(len(self.floors), 2)):
for direction in [-1, 1]:
target_floor = entry_floor + offset * direction
if target_floor < 0 or target_floor >= len(self.floors):
continue
floor = self.floors[target_floor]
for slot_type in self.COMPATIBLE_SLOTS[car_type]:
ticket = floor.park(slot_type)
if ticket:
return ticket

return None

class StreamingTopK:
"""
从数据流中实时维护 Top K 频繁元素
add() 复杂度: O(log n)
getTopK() 复杂度: O(k log k) 或 O(n log k)
"""

def __init__(self):
# 记录每个元素的频率
self.freq_map: Dict[int, int] = defaultdict(int)
# 维护所有元素及其频率的最大堆
self.heap: List[tuple] = []
self.seen: set = set()

def add(self, num: int) -> None:
"""
添加一个元素到数据流中
使用哈希表记录频率，同时维护堆
"""
self.freq_map[num] += 1
if num not in self.seen:
# 新元素，直接入堆
heapq.heappush(self.heap, (-self.freq_map[num], num))
self.seen.add(num)
else:
# 已存在元素，需要更新频率
# 堆不支持直接更新，所以标记为脏数据，惰性删除
self._dirty[num] = True
heapq.heappush(self.heap, (-self.freq_map[num], num))

def getTopK(self, k: int) -> List[int]:
"""
返回当前频率最高的 K 个元素
使用惰性删除策略清理堆中脏数据
"""
result = []
temp = []

while self.heap and len(result) < k: neg_freq, num = heapq.heappop(self.heap) # 惰性删除：跳过脏数据 if self._dirty.get(num, False): del self._dirty[num] continue # 验证频率是否匹配 if -neg_freq != self.freq_map[num]: continue result.append(num) # 恢复堆 for item in temp: heapq.heappush(self.heap, item) return result class OptimizedStreamingTopK: """ 优化版本：使用最小堆维护 Top K 当 K 远小于 n 时更高效 """ def __init__(self, k: int): self.k = k self.freq_map: Dict[int, int] = defaultdict(int) # 最小堆，维护当前 Top K 个元素 self.min_heap: List[tuple] = [] def add(self, num: int) -> None:
self.freq_map[num] += 1
freq = self.freq_map[num]

if len(self.min_heap) < self.k: heapq.heappush(self.min_heap, (freq, num)) elif freq > self.min_heap[0][0]:
# 新元素频率超过堆顶，替换
heapq.heapreplace(self.min_heap, (freq, num))

class LRUCacheWithTTL:
"""
带 TTL 过期机制的 LRU Cache
get() 和 set() 均为 O(1) 时间复杂度
使用惰性过期策略：访问时检查过期，定期清理
"""

def __init__(self, capacity: int):
self.capacity = capacity
# OrderedDict 维护访问顺序 + 键值映射
self.cache: OrderedDict = OrderedDict()
# 存储每个 key 的过期时间戳
self.expiry: Dict[str, float] = {}

def get(self, key: str) -> Optional[int]:
"""
获取值，如果不存在或已过期则返回 None
"""
if key not in self.cache:
return None

# 检查是否过期
if time.time() > self.expiry[key]:
# 惰性删除过期条目
del self.cache[key]
del self.expiry[key]
return None

# 移动到末尾（最近使用）
self.cache.move_to_end(key)
return self.cache[key]

def set(self, key: str, value: int, ttl: float = 300) -> None:
"""
设置键值对，指定 TTL（秒）
默认 TTL 为 5 分钟
"""
if key in self.cache:
# 更新已有 key，移动到末尾
self.cache.move_to_end(key)
self.cache[key] = value
else:
# 新 key，检查容量
if len(self.cache) >= self.capacity:
# 移除最久未使用的
oldest_key, _ = self.cache.popitem(last=False)
self.expiry.pop(oldest_key, None)
self.cache[key] = value

# 设置过期时间
self.expiry[key] = time.time() + ttl

def cleanup_expired(self) -> int:
"""
主动清理所有过期条目
返回清理的数量
"""
now = time.time()
expired_keys = [
key for key, exp in self.expiry.items()
if now > exp
]
for key in expired_keys:
self.cache.pop(key, None)
del self.expiry[key]
return len(expired_keys)

class LRUCacheWithTTLAndCleanup:
"""
生产级版本：支持后台自动清理过期条目
使用定时器避免每次 get/set 都扫描过期条目
"""

def __init__(self, capacity: int, cleanup_interval: float = 60.0):
self.capacity = capacity
self.cache = OrderedDict()
self.expiry = {}
self.lock = threading.RLock()

# 后台清理定时器
self.cleanup_interval = cleanup_interval
self._start_cleanup_thread()

def _start_cleanup_thread(self):
"""启动后台清理线程"""
self._running = True
self._thread = threading.Thread(
target=self._cleanup_loop, daemon=True
)
self._thread.start()

def _cleanup_loop(self):
"""周期性清理过期条目"""
while self._running:
time.sleep(self.cleanup_interval)
with self.lock:
self.cleanup_expired()

def get(self, key: str) -> Optional[int]:
with self.lock:
if key not in self.cache:
return None
if time.time() > self.expiry[key]:
del self.cache[key]
del self.expiry[key]
return None
self.cache.move_to_end(key)
return self.cache[key]

def set(self, key: str, value: int, ttl: float = 300) -> None:
with self.lock:
if key in self.cache:
self.cache.move_to_end(key)
self.cache[key] = value
else:
if len(self.cache) >= self.capacity:
oldest, _ = self.cache.popitem(last=False)
self.expiry.pop(oldest, None)
self.cache[key] = value
self.expiry[key] = time.time() + ttl

def cleanup_expired(self) -> int:
now = time.time()
expired = [k for k, v in self.expiry.items() if now > v]
for key in expired:
self.cache.pop(key, None)
del self.expiry[key]
return len(expired)

class URLGenerator:
"""短 URL 编码方案"""

BASE62_CHARS = "abcdefghijklmnopqrstuvwxyz" + \
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" + \
"0123456789"

@staticmethod
def encode_id(num: int) -> str:
"""将数字编码为 Base62 字符串"""
if num == 0:
return URLGenerator.BASE62_CHARS[0]

chars = []
base = len(URLGenerator.BASE62_CHARS)
while num > 0:
num, remainder = divmod(num, base)
chars.append(URLGenerator.BASE62_CHARS[remainder])

return ''.join(reversed(chars))

@staticmethod
def decode_id(short: str) -> int:
"""将 Base62 字符串解码为数字"""
base = len(URLGenerator.BASE62_CHARS)
char_map = {c: i for i, c in enumerate(URLGenerator.BASE62_CHARS)}
result = 0
for char in short:
result = result * base + char_map[char]
return result

@staticmethod
def generate_from_url(url: str) -> str:
"""基于 URL Hash 生成短码（备用方案）"""
hash_val = int(hashlib.md5(url.encode()).hexdigest(), 16)
return URLGenerator.encode_id(hash_val)

class SnowflakeIDGenerator:
"""
分布式 ID 生成器（Snowflake 算法）
64-bit: 1bit(符号) + 41bit(时间戳) + 10bit(机器ID) + 12bit(序列号)
"""

EPOCH = 1609459200000 # 2021-01-01

def __init__(self, machine_id: int):
assert 0 <= machine_id < 1024 self.machine_id = machine_id self.sequence = 0 self.last_timestamp = -1 def generate(self) -> int:
timestamp = int(time.time() * 1000)