@Configuration
public class DeadLetterConfig {
    
    // Основной DLX
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange("dlx.exchange", true, false);
    }
    
    // Очередь для мертвых писем
    @Bean
    public Queue dlQueue() {
        return QueueBuilder.durable("dead.letter.queue")
            .withArgument("x-max-length", 10000) // Ограничение размера
            .withArgument("x-message-ttl", 86400000) // 24 часа хранения
            .build();
    }
    
    @Bean
    public Binding dlBinding() {
        return BindingBuilder.bind(dlQueue())
            .to(dlxExchange())
            .with("#"); // Все routing keys
    }
    
    // Рабочая очередь с настройкой DLX
    @Bean
    public Queue orderProcessingQueue() {
        return QueueBuilder.durable("orders.processing.queue")
            .withArgument("x-dead-letter-exchange", "dlx.exchange")
            .withArgument("x-dead-letter-routing-key", "orders.failed")
            .withArgument("x-max-retries", 3) // Кастомный аргумент
            .build();
    }
}

@Component
public class DeadLetterProcessor {
    
    @RabbitListener(queues = "dead.letter.queue")
    public void handleDeadLetter(Message failedMessage,
                                Channel channel,
                                @Header(AmqpHeaders.DELIVERY_TAG) long tag,
                                @Header(AmqpHeaders.RECEIVED_ROUTING_KEY) String routingKey,
                                @Header(AmqpHeaders.RECEIVED_EXCHANGE) String exchange,
                                @Header("x-death") List<Map<String, Object>> deaths) {
        
        // Анализ причины попадания в DLQ
        String reason = analyzeFailureReason(deaths);
        
        log.error("Dead letter received: routingKey={}, reason={}, deaths={}", 
                 routingKey, reason, deaths);
        
        // Логика обработки в зависимости от причины
        if (isRecoverable(failedMessage, deaths)) {
            handleRecoverableMessage(failedMessage);
        } else {
            handlePermanentFailure(failedMessage);
        }
        
        // Подтверждение обработки DLQ
        channel.basicAck(tag, false);
    }
    
    private String analyzeFailureReason(List<Map<String, Object>> deaths) {
        if (deaths != null && !deaths.isEmpty()) {
            Map<String, Object> lastDeath = deaths.get(0);
            return (String) lastDeath.get("reason");
        }
        return "unknown";
    }
    
    private void handleRecoverableMessage(Message message) {
        // Пример: повторная отправка после задержки
        String originalQueue = extractOriginalQueue(message);
        long delay = calculateRetryDelay(message);
        
        retryService.scheduleRetry(message, originalQueue, delay);
    }
    
    private void handlePermanentFailure(Message message) {
        // Архивирование неудачных сообщений
        archiveService.archiveFailedMessage(message);
        
        // Уведомление команды поддержки
        alertService.notifySupportTeam(message);
    }
}

@Configuration
public class DelayedRetryConfig {
    
    // Exchange для отложенных повторных попыток
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        
        return new CustomExchange(
            "delayed.retry.exchange",
            "x-delayed-message",
            true,
            false,
            args
        );
    }
    
    // Очередь для отложенных повторных попыток
    @Bean
    public Queue delayedRetryQueue() {
        return new Queue("delayed.retry.queue", true);
    }
    
    @Bean
    public Binding delayedBinding() {
        return BindingBuilder.bind(delayedRetryQueue())
            .to(delayedExchange())
            .with("retry.key")
            .noargs();
    }
    
    // Сервис для отложенных повторных попыток
    @Service
    public class DelayedRetryService {
        private final RabbitTemplate rabbitTemplate;
        
        public void scheduleRetry(Message message, int attempt) {
            long delay = calculateExponentialBackoff(attempt);
            
            rabbitTemplate.convertAndSend(
                "delayed.retry.exchange",
                "retry.key",
                message,
                m -> {
                    // Установка задержки
                    m.getMessageProperties()
                        .setHeader("x-delay", delay);
                    
                    // Сохранение номера попытки
                    m.getMessageProperties()
                        .setHeader("retry-attempt", attempt);
                    
                    return m;
                }
            );
        }
        
        private long calculateExponentialBackoff(int attempt) {
            return (long) Math.pow(2, attempt) * 1000; // Экспоненциальная задержка
        }
    }
}

public class Task070126 {
    public static void main(String[] args) {
        new Child070126();
    }
}

class Parent070126 {
    Parent070126() {
        print();
    }
    
    void print() {
        System.out.println("Parent");
    }
}

class Child070126 extends Parent070126 {
    private String value = "Hello";
    
    Child070126() {
        System.out.println("Child constructor");
    }
    
    @Override
    void print() {
        System.out.println(value.length());
    }
}

public class LinearSearch {
    public static Contact findContact(List<Contact> contacts, String name) {
        for (Contact contact : contacts) {
            if (contact.getName().equals(name)) {
                return contact;
            }
        }
        return null; // Контакт не найден
    }
}

public class IndexedSearch {
    private Map<String, Contact> contactIndex;
    
    public IndexedSearch(List<Contact> contacts) {
        // Предварительная обработка: построение индекса
        contactIndex = new HashMap<>();
        for (Contact contact : contacts) {
            contactIndex.put(contact.getName(), contact);
        }
    }
    
    public Contact findContact(String name) {
        // Поиск по индексу за постоянное время
        return contactIndex.get(name);
    }
}

public class CachedSearch {
    private List<Contact> contacts;
    private Map<String, Contact> cache;
    private int cacheHits = 0;
    private int cacheMisses = 0;
    
    public CachedSearch(List<Contact> contacts) {
        this.contacts = contacts;
        this.cache = new HashMap<>();
    }
    
    public Contact findContact(String name) {
        // Проверка кэша
        Contact cached = cache.get(name);
        if (cached != null) {
            cacheHits++;
            return cached;
        }
        
        // Кэш-промах: выполняем линейный поиск
        cacheMisses++;
        for (Contact contact : contacts) {
            if (contact.getName().equals(name)) {
                // Сохраняем результат в кэш для будущих запросов
                cache.put(name, contact);
                return contact;
            }
        }
        return null;
    }
    
    public double getCacheHitRatio() {
        int total = cacheHits + cacheMisses;
        return total > 0 ? (double) cacheHits / total : 0.0;
    }
}

// Неэффективный алгоритм дедупликации O(n²)
public List<Record> deduplicateNaive(List<Record> records) {
    List<Record> unique = new ArrayList<>();
    for (Record r1 : records) {
        boolean isDuplicate = false;
        for (Record r2 : unique) {
            if (r1.equals(r2)) {
                isDuplicate = true;
                break;
            }
        }
        if (!isDuplicate) {
            unique.add(r1);
        }
    }
    return unique;
}

// Эффективный алгоритм дедупликации O(n log n)
public List<Record> deduplicateEfficient(List<Record> records) {
    if (records.isEmpty()) return Collections.emptyList();
    
    // Сортировка позволяет находить дубликаты за один проход
    List<Record> sorted = new ArrayList<>(records);
    Collections.sort(sorted);
    
    List<Record> unique = new ArrayList<>();
    Record previous = sorted.get(0);
    unique.add(previous);
    
    for (int i = 1; i < sorted.size(); i++) {
        Record current = sorted.get(i);
        if (!current.equals(previous)) {
            unique.add(current);
            previous = current;
        }
    }
    return unique;
}

import java.util.*;

public class Task080126 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Comparator<Integer> comparator = (a, b) -> b - a;
        int index = Collections.binarySearch(list, 1, comparator);
        System.out.println(index);
    }
}

public class ConstantTimeExample {
    private int[] array;
    
    public int getElement(int index) {
        // Всегда выполняется за фиксированное время
        return array[index];
    }
    
    public boolean isEven(int number) {
        // Математическая операция также O(1)
        return number % 2 == 0;
    }
}

public class BinarySearch {
    public static int search(int[] sortedArray, int target) {
        int left = 0;
        int right = sortedArray.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2; // Избегаем переполнения
            
            if (sortedArray[mid] == target) {
                return mid;
            } else if (sortedArray[mid] < target) {
                left = mid + 1; // Отбрасываем левую половину
            } else {
                right = mid - 1; // Отбрасываем правую половину
            }
        }
        return -1; // Элемент не найден
    }
}

public class LinearTimeExample {
    public static int findMax(int[] array) {
        if (array.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        }
        
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

public class MergeSort {
    public static void sort(int[] array) {
        if (array.length <= 1) return;
        
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        
        sort(left);
        sort(right);
        
        merge(array, left, right);
    }
    
    private static void merge(int[] result, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                result[k++] = left[i++];
            } else {
                result[k++] = right[j++];
            }
        }
        
        while (i < left.length) result[k++] = left[i++];
        while (j < right.length) result[k++] = right[j++];
    }
}

public class BubbleSort {
    public static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // Обмен элементов
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

public class ExponentialExample {
    // Наивная рекурсивная реализация Фибоначчи: O(2ⁿ)
    public static long fibonacciNaive(int n) {
        if (n <= 1) return n;
        return fibonacciNaive(n - 1) + fibonacciNaive(n - 2);
    }
    
    // Динамическое программирование: O(n)
    public static long fibonacciDP(int n) {
        if (n <= 1) return n;
        
        long[] fib = new long[n + 1];
        fib[0] = 0;
        fib[1] = 1;
        
        for (int i = 2; i <= n; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        
        return fib[n];
    }
}

public class QuickSort {
    public static void sort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }
    
    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // Разделение массива
            int pivotIndex = partition(array, low, high);
            
            // Рекурсивная сортировка частей
            quickSort(array, low, pivotIndex - 1);
            quickSort(array, pivotIndex + 1, high);
        }
    }
    
    private static int partition(int[] array, int low, int high) {
        int pivot = array[high]; // Выбор опорного элемента
        int i = low - 1;
        
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) {
                i++;
                swap(array, i, j);
            }
        }
        
        swap(array, i + 1, high);
        return i + 1;
    }
    
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

public class OptimizedQuickSort {
    private static final int INSERTION_THRESHOLD = 16;
    
    public static void sort(int[] array) {
        randomizedQuickSort(array, 0, array.length - 1);
    }
    
    private static void randomizedQuickSort(int[] array, int low, int high) {
        // Для маленьких массивов используем сортировку вставками
        if (high - low < INSERTION_THRESHOLD) {
            insertionSort(array, low, high);
            return;
        }
        
        // Рандомизированный выбор опорного элемента
        int randomIndex = low + (int)(Math.random() * (high - low + 1));
        swap(array, randomIndex, high);
        
        int pivotIndex = partition(array, low, high);
        randomizedQuickSort(array, low, pivotIndex - 1);
        randomizedQuickSort(array, pivotIndex + 1, high);
    }
}

public class Task090126 {
    public static void main(String[] args) {
        int n = 10;
        int count = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j += i) {
                count++;
            }
        }
        System.out.println(count);
    }
}