def hash_element(element):
    """원소를 해시값으로 변환"""
    import hashlib
    hash_value = hashlib.md5(str(element).encode()).hexdigest()
    return int(hash_value, 16)

def count_leading_zeros(hash_value):
    """해시값의 앞쪽 0의 개수 계산"""
    binary = bin(hash_value)[2:]  # '0b' 제거
    leading_zeros = 0
    for bit in binary:
        if bit == '0':
            leading_zeros += 1
        else:
            break
    return leading_zeros

def estimate_cardinality(leading_zero_counts, m):
    """카디널리티 추정"""
    import math
    
    # 조화 평균 계산
    harmonic_mean = m / sum(2**(-count) for count in leading_zero_counts)
    
    # 보정 계수 적용
    alpha_m = {
        16: 0.673, 32: 0.697, 64: 0.709, 128: 0.715, 256: 0.718,
        512: 0.720, 1024: 0.722, 2048: 0.723, 4096: 0.724
    }
    
    raw_estimate = alpha_m.get(m, 0.7213 / (1 + 1.079 / m)) * m * harmonic_mean
    
    # 소규모 보정
    if raw_estimate <= 2.5 * m:
        zeros = leading_zero_counts.count(0)
        if zeros > 0:
            return m * math.log(m / zeros)
    
    # 대규모 보정
    if raw_estimate > (2**32) / 30:
        return -(2**32) * math.log(1 - raw_estimate / (2**32))
    
    return raw_estimate

class RealTimeWebAnalytics:
    def __init__(self):
        self.daily_users = HyperLogLog(precision=14)  # 99.9% 정확도
        self.hourly_users = HyperLogLog(precision=12)  # 99% 정확도
        self.realtime_users = HyperLogLog(precision=10)  # 95% 정확도
    
    def process_event(self, user_id, timestamp):
        """실시간 이벤트 처리"""
        # 일일 활성 사용자 추정
        self.daily_users.add(user_id)
        
        # 시간별 활성 사용자 추정
        if self.is_current_hour(timestamp):
            self.hourly_users.add(user_id)
        
        # 실시간 활성 사용자 추정 (최근 5분)
        if self.is_recent_5min(timestamp):
            self.realtime_users.add(user_id)
    
    def get_metrics(self):
        """실시간 메트릭 반환"""
        return {
            "daily_active_users": self.daily_users.estimate(),
            "hourly_active_users": self.hourly_users.estimate(),
            "realtime_active_users": self.realtime_users.estimate()
        }

class MarketingAnalytics:
    def __init__(self):
        self.campaign_clicks = {}
        self.campaign_purchases = {}
        self.ab_test_groups = {}
    
    def track_campaign_click(self, user_id, campaign_id, ab_test_group=None):
        """캠페인 클릭 추적"""
        if campaign_id not in self.campaign_clicks:
            self.campaign_clicks[campaign_id] = HyperLogLog(precision=12)
        
        self.campaign_clicks[campaign_id].add(user_id)
        
        # A/B 테스트 그룹별 추적
        if ab_test_group:
            key = f"{campaign_id}_{ab_test_group}"
            if key not in self.ab_test_groups:
                self.ab_test_groups[key] = HyperLogLog(precision=12)
            self.ab_test_groups[key].add(user_id)
    
    def track_purchase(self, user_id, campaign_id):
        """구매 추적"""
        if campaign_id not in self.campaign_purchases:
            self.campaign_purchases[campaign_id] = HyperLogLog(precision=12)
        
        self.campaign_purchases[campaign_id].add(user_id)
    
    def get_campaign_metrics(self, campaign_id):
        """캠페인 메트릭 계산"""
        clicks = self.campaign_clicks.get(campaign_id, HyperLogLog()).estimate()
        purchases = self.campaign_purchases.get(campaign_id, HyperLogLog()).estimate()
        
        return {
            "unique_clicks": clicks,
            "unique_purchases": purchases,
            "conversion_rate": purchases / clicks if clicks > 0 else 0
        }
    
    def get_ab_test_results(self, campaign_id):
        """A/B 테스트 결과 비교"""
        results = {}
        for group in ["A", "B"]:
            key = f"{campaign_id}_{group}"
            if key in self.ab_test_groups:
                results[group] = {
                    "unique_clicks": self.ab_test_groups[key].estimate(),
                    "conversion_rate": self.get_campaign_metrics(campaign_id)["conversion_rate"]
                }
        return results

class NetworkSecurityMonitor:
    def __init__(self):
        self.ip_tracker = HyperLogLog(precision=14)
        self.port_tracker = HyperLogLog(precision=10)
        self.attack_threshold = 100000  # IP 수 임계값
    
    def monitor_traffic(self, ip_address, port, timestamp):
        """네트워크 트래픽 모니터링"""
        # 고유 IP 주소 추적
        self.ip_tracker.add(ip_address)
        
        # 고유 포트 추적
        self.port_tracker.add(port)
        
        # DDoS 공격 탐지
        unique_ips = self.ip_tracker.estimate()
        if unique_ips > self.attack_threshold:
            self.trigger_alert(unique_ips, timestamp)
    
    def trigger_alert(self, ip_count, timestamp):
        """보안 알림 트리거"""
        alert = {
            "type": "DDoS_ATTACK_DETECTED",
            "timestamp": timestamp,
            "unique_ip_count": ip_count,
            "severity": "HIGH"
        }
        # 알림 시스템에 전송
        self.send_alert(alert)
    
    def get_security_metrics(self):
        """보안 메트릭 반환"""
        return {
            "unique_ip_addresses": self.ip_tracker.estimate(),
            "unique_ports": self.port_tracker.estimate(),
            "attack_probability": self.calculate_attack_probability()
        }

import hashlib
import math
from collections import defaultdict

class HyperLogLog:
    def __init__(self, precision=14):
        """
        HyperLogLog 초기화
        
        Args:
            precision: 정밀도 (4-16, 기본값 14)
                      높을수록 정확하지만 메모리 사용량 증가
        """
        self.precision = precision
        self.m = 2 ** precision  # 버킷 수
        self.registers = [0] * self.m
        
        # 조정 계수
        self.alpha = self._calculate_alpha()
        
        # 해시 함수 설정
        self.hash_func = hashlib.md5
    
    def _calculate_alpha(self):
        """조정 계수 계산"""
        alpha_values = {
            4: 0.673, 5: 0.697, 6: 0.709, 7: 0.715, 8: 0.718,
            9: 0.720, 10: 0.722, 11: 0.723, 12: 0.724, 13: 0.725,
            14: 0.726, 15: 0.727, 16: 0.728
        }
        return alpha_values.get(self.precision, 0.7213 / (1 + 1.079 / self.m))
    
    def add(self, element):
        """원소 추가"""
        # 해시값 계산
        hash_value = self._hash(element)
        
        # 버킷 인덱스와 값 계산
        bucket_index = hash_value & (self.m - 1)
        value = self._count_leading_zeros(hash_value >> self.precision)
        
        # 레지스터 업데이트
        self.registers[bucket_index] = max(self.registers[bucket_index], value)
    
    def _hash(self, element):
        """해시값 계산"""
        hash_obj = self.hash_func(str(element).encode('utf-8'))
        return int(hash_obj.hexdigest()[:8], 16)
    
    def _count_leading_zeros(self, value):
        """앞쪽 0의 개수 계산"""
        if value == 0:
            return 32 - self.precision
        
        leading_zeros = 0
        while (value & 0x80000000) == 0:
            leading_zeros += 1
            value <<= 1
        return leading_zeros
    
    def estimate(self):
        """카디널리티 추정"""
        # 조화 평균 계산
        harmonic_mean = 0
        empty_registers = 0
        
        for register in self.registers:
            if register == 0:
                empty_registers += 1
            else:
                harmonic_mean += 2 ** (-register)
        
        # 추정값 계산
        raw_estimate = self.alpha * (self.m ** 2) / harmonic_mean
        
        # 소규모 보정
        if raw_estimate <= 2.5 * self.m and empty_registers > 0:
            return self.m * math.log(self.m / empty_registers)
        
        # 대규모 보정
        if raw_estimate > (2 ** 32) / 30:
            return -(2 ** 32) * math.log(1 - raw_estimate / (2 ** 32))
        
        return raw_estimate
    
    def merge(self, other):
        """다른 HyperLogLog와 병합"""
        if self.precision != other.precision:
            raise ValueError("Precision must be the same for merging")
        
        for i in range(self.m):
            self.registers[i] = max(self.registers[i], other.registers[i])
    
    def get_memory_usage(self):
        """메모리 사용량 반환 (바이트)"""
        return self.m * 4  # 각 레지스터는 4바이트

import multiprocessing as mp
from functools import partial

class ParallelHyperLogLog:
    def __init__(self, precision=14, num_workers=4):
        self.precision = precision
        self.num_workers = num_workers
        self.workers = []
        
        # 워커별 HyperLogLog 생성
        for _ in range(num_workers):
            self.workers.append(HyperLogLog(precision))
    
    def add_batch(self, elements):
        """배치 원소 추가 (병렬 처리)"""
        chunk_size = len(elements) // self.num_workers
        chunks = [elements[i:i + chunk_size] 
                 for i in range(0, len(elements), chunk_size)]
        
        # 병렬 처리
        with mp.Pool(self.num_workers) as pool:
            worker_func = partial(self._worker_add_elements)
            pool.map(worker_func, zip(self.workers, chunks))
    
    def _worker_add_elements(self, worker_data):
        """워커별 원소 처리"""
        worker, elements = worker_data
        for element in elements:
            worker.add(element)
    
    def estimate(self):
        """병합 후 카디널리티 추정"""
        # 모든 워커 병합
        merged = self.workers[0]
        for worker in self.workers[1:]:
            merged.merge(worker)
        
        return merged.estimate()

class StreamingHyperLogLog:
    def __init__(self, precision=14, window_size=3600):
        self.precision = precision
        self.window_size = window_size
        self.windows = {}
        self.current_time = 0
    
    def add_with_timestamp(self, element, timestamp):
        """타임스탬프와 함께 원소 추가"""
        # 시간 윈도우 계산
        window_id = timestamp // self.window_size
        
        # 새 윈도우 생성
        if window_id not in self.windows:
            self.windows[window_id] = HyperLogLog(self.precision)
        
        # 원소 추가
        self.windows[window_id].add(element)
        
        # 오래된 윈도우 정리
        self._cleanup_old_windows(window_id)
    
    def _cleanup_old_windows(self, current_window):
        """오래된 윈도우 정리"""
        cutoff = current_window - 24  # 24시간 보관
        old_windows = [w for w in self.windows.keys() if w < cutoff]
        for window in old_windows:
            del self.windows[window]
    
    def get_window_estimate(self, window_id):
        """특정 윈도우의 카디널리티 추정"""
        if window_id in self.windows:
            return self.windows[window_id].estimate()
        return 0
    
    def get_rolling_estimate(self, hours=1):
        """롤링 윈도우 카디널리티 추정"""
        current_window = self.current_time // self.window_size
        windows_to_merge = range(current_window - hours, current_window + 1)
        
        merged = HyperLogLog(self.precision)
        for window_id in windows_to_merge:
            if window_id in self.windows:
                merged.merge(self.windows[window_id])
        
        return merged.estimate()