int low = 0, high = books.size() - 1; 

while (low <= high) {
        mid = (low + high) / 2; cmp = books.get(mid).getAuthor().compareTo(author);

        if (cmp < 0) low = mid + 1; 
        else if (cmp > 0) high = mid - 1;
        else { // Найден, найти первый: 
                  while (mid > 0 && books.get(mid-1).getAuthor().equals(author)) 
                  mid--; 
                  return books.get(mid); 
                } 
}

public class Task270126 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("12345");
        sb.append(sb.append("6"));
        System.out.println(sb.toString());
    }
}

public class RecursionFundamentals {

    /**
     * Вычисляет факториал числа n.
     * 
     * @param n неотрицательное целое число
     * @return n!
     * @throws IllegalArgumentException если n отрицательно
     */
    public static long factorial(int n) {
        // Базовый случай: факториал 0 или 1 равен 1
        // Это математическое определение, служащее якорем рекурсии
        if (n <= 1) {
            return 1;
        }
        
        // Защита от некорректного использования
        if (n < 0) {
            throw new IllegalArgumentException("Factorial undefined for negative numbers");
        }
        
        // Рекурсивный шаг: n! = n * (n-1)!
        // Здесь мы полагаемся на то, что factorial(n-1) вернет правильный результат
        // и умножаем его на n для получения текущего значения
        return n * factorial(n - 1);
    }
}

public class StackDepthDemo {
    
    private static int depth = 0;
    
    public static void recursiveCall() {
        depth++;
        if (depth % 1000 == 0) {
            System.out.println("Current depth: " + depth);
        }
        recursiveCall(); // Бесконечная рекурсия без базового случая
    }
    
    public static void main(String[] args) {
        try {
            recursiveCall();
        } catch (StackOverflowError e) {
            System.err.println("Stack overflow at depth: " + depth);
            // Вывод примерно: Stack overflow at depth: 10800 (зависит от -Xss)
        }
    }
}

public static long factorialTail(int n, long accumulator) {
    if (n <= 1) {
        return accumulator;
    }
    // Рекурсивный вызов — последняя операция перед return
    // Теоретически JVM могла бы освободить текущий фрейм перед вызовом
    return factorialTail(n - 1, n * accumulator);
}

import java.io.File;

public class FileSystemTraversal {

    /**
     * Рекурсивно подсчитывает общий размер всех файлов в директории.
     * 
     * @param directory корневая директория для анализа
     * @return суммарный размер в байтах
     */
    public static long calculateDirectorySize(File directory) {
        // Базовый случай 1: несуществующий путь
        if (!directory.exists()) {
            return 0;
        }
        
        // Базовый случай 2: это файл, а не директория
        // Возвращаем его размер, рекурсия останавливается
        if (directory.isFile()) {
            return directory.length();
        }
        
        // Базовый случай 3: пустая директория (опционально, обработается циклом)
        
        // Рекурсивный шаг: получаем список содержимого
        File[] children = directory.listFiles();
        if (children == null) {
            // Защита от null при отсутствии прав доступа
            return 0;
        }
        
        long totalSize = 0;
        // Для каждого элемента в директории вызываем себя рекурсивно
        for (File child : children) {
            // Рекурсивный вызов обрабатывает поддиректории на любую глубину
            totalSize += calculateDirectorySize(child);
        }
        
        return totalSize;
    }
}

public class Task280126 {
    public static void main(String[] args) {

        System.out.println(f(7));

    }

    static int f(int n) {

        if (n <= 1) return 1;
        return f(n - 2) + f(n - 1);

    }
}

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

public class FileSizeCalculator {

    /**
     * Вычисляет общий размер всех файлов в каталоге и его подкаталогах.
     * 
     * @param rootPath корневой каталог для анализа
     * @return суммарный размер в байтах
     * @throws IllegalArgumentException если rootPath не является каталогом или не существует
     */
    public static long calculateSize(Path rootPath) {
        if (rootPath == null) {
            throw new IllegalArgumentException("Path cannot be null");
        }
        
        // Проверяем существование и тип файловой системы
        if (!Files.exists(rootPath)) {
            throw new IllegalArgumentException("Path does not exist: " + rootPath);
        }
        
        if (!Files.isDirectory(rootPath)) {
            throw new IllegalArgumentException("Path is not a directory: " + rootPath);
        }
        
        try {
            return calculateRecursive(rootPath);
        } catch (IOException e) {
            // Преобразуем checked exception в unchecked для удобства API
            throw new UncheckedIOException("Failed to traverse directory: " + rootPath, e);
        }
    }
    
    /**
     * Внутренний рекурсивный метод.
     * 
     * @param currentPath текущий узел для анализа
     * @return суммарный размер поддерева
     */
    private static long calculateRecursive(Path currentPath) throws IOException {
        // Базовый случай 1: это файл
        if (Files.isRegularFile(currentPath)) {
            try {
                return Files.size(currentPath);
            } catch (SecurityException | IOException e) {
                // В реальном приложении логгируем ошибку доступа
                // и продолжаем, а не прокидываем исключение
                System.err.println("Cannot access file: " + currentPath + " - " + e.getMessage());
                return 0;
            }
        }
        
        //случай 2: это директория, обрабатываем её содержимое
        long totalSize = 0;
        
        // Используем try-with-resources для безопасного закрытия DirectoryStream
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(currentPath)) {
            for (Path child : stream) {
                // Рекурсивный вызов для каждого дочернего элемента
                // Глубина рекурсии = уровень вложенности директорий
                totalSize += calculateRecursive(child);
            }
        } catch (NotDirectoryException e) {
            // Это не должно случиться из-за проверки выше, но защита от race condition
            return 0;
        } catch (SecurityException e) {
            System.err.println("Access denied to directory: " + currentPath);
            return 0;
        }
        
        return totalSize;
   }
}

private static long calculateRecursiveSafe(Path currentPath, Set<Path> visited) throws IOException {
    // Проверка на цикл
    if (!visited.add(currentPath.toRealPath())) {
        System.err.println("Cycle detected, skipping: " + currentPath);
        return 0;
    }
    
    if (Files.isRegularFile(currentPath)) {
        return Files.size(currentPath);
    }
    
    long totalSize = 0;
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(currentPath)) {
        for (Path child : stream) {
            totalSize += calculateRecursiveSafe(child, visited);
        }
    }
    
    // Важно: не удаляем из visited при возврате, так как путь может быть повторен через другую ссылку
    return totalSize;
}

Литература
├── Художественная
│   ├── Фантастика
│   │   ├── Космическая
│   │   └── Альтернативная история
│   └── Детектив
└── Научная
    └── Программирование
        └── Java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class GenreNode {
    private final String name;
    private final List<GenreNode> subgenres;
    private final List<Book> books; // Книги непосредственно этого жанра
    
    public GenreNode(String name) {
        this.name = name;
        this.subgenres = new ArrayList<>();
        this.books = new ArrayList<>();
    }
    
    // Методы добавления поджанров и книг...
    public void addSubgenre(GenreNode subgenre) {
        subgenres.add(subgenre);
    }
    
    public void addBook(Book book) {
        books.add(book);
    }
    
    public String getName() {
        return name;
    }
    
    public List<GenreNode> getSubgenres() {
        return Collections.unmodifiableList(subgenres);
    }
    
    public List<Book> getBooks() {
        return Collections.unmodifiableList(books);
    }
}

class Book {
    final String title;
    final String author;
    
    Book(String title, String author) {
        this.title = title;
        this.author = author;
    }
}