public class ComplexVariableAssignmentChallenge {
    public static void main(String[] args) {
        int intVar1 = 8;
        int intVar2 = 3;
        double doubleVar1 = 4.5;
        double doubleVar2 = 2.5;
        String strVar1 = "Sum: ";
        String strVar2 = "Product: ";

        String resultSum = strVar1 + (intVar1 + doubleVar1) + ", " + (intVar2 + doubleVar2);
        String resultProduct = strVar2 + (intVar1 * doubleVar1) + ", " + (intVar2 * doubleVar2);
        System.out.println(resultSum);
        System.out.println(resultProduct);
    }
}

TreeMap<String, Integer> map = new TreeMap<>();

TreeMap<String, Integer> map = new TreeMap<>(Comparator.reverseOrder());

Map<String, Integer> anotherMap = new HashMap<>();
TreeMap<String, Integer> map = new TreeMap<>(anotherMap);

SortedMap<String, Integer> sortedMap = new TreeMap<>(anotherMap);
TreeMap<String, Integer> map = new TreeMap<>(sortedMap);

TreeMap<String, Integer> map = new TreeMap<>();
map.put("Apple", 50);
map.put("Banana", 30);
map.put("Orange", 20);

Integer value = map.get("Apple");
System.out.println("Value for key 'Apple': " + value);

Integer removedValue = map.remove("Banana");
System.out.println("Removed value: " + removedValue);

boolean contains = map.containsKey("Orange");
System.out.println("Contains key 'Orange': " + contains);

boolean containsValue = map.containsValue(20);
System.out.println("Contains value 20: " + containsValue);

int size = map.size();
System.out.println("Size of the map: " + size);

boolean isEmpty = map.isEmpty();
System.out.println("Is the map empty: " + isEmpty);

map.clear();
System.out.println("Size after clear: " + map.size());

String firstKey = map.firstKey();
System.out.println("First key: " + firstKey);

String lastKey = map.lastKey();
System.out.println("Last key: " + lastKey);

Map.Entry<String, Integer> firstEntry = map.pollFirstEntry();
System.out.println("Polled first entry: " + firstEntry);

Map.Entry<String, Integer> lastEntry = map.pollLastEntry();
System.out.println("Polled last entry: " + lastEntry);

TreeMap<String, Integer> map = new TreeMap<>();
map.put("Apple", 50);
map.put("Banana", 30);
map.put("Orange", 20);

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

map.put("Grapes", 40);
SortedMap<String, Integer> subMap = map.subMap("Apple", "Orange");
for (Map.Entry<String, Integer> entry : subMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

NavigableMap<String, Integer> tailMap = map.tailMap("Banana", true);
for (Map.Entry<String, Integer> entry : tailMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

import java.util.WeakHashMap;
import java.util.Map;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<String, String> weakMap = new WeakHashMap<>();
        
        String key1 = new String("key1");
        String key2 = new String("key2");
        
        weakMap.put(key1, "value1");
        weakMap.put(key2, "value2");

        System.out.println("Before GC: " + weakMap);
        
        key1 = null;
        System.gc();
        
        // Подождем немного, чтобы GC мог удалить key1
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("After GC: " + weakMap);
    }
}

WeakHashMap<String, Integer> map = new WeakHashMap<>();
map.put("Apple", 50);
map.put("Banana", 30);

Integer value = map.get("Apple");
System.out.println("Value for key 'Apple': " + value);

Integer removedValue = map.remove("Banana");
System.out.println("Removed value: " + removedValue);

boolean contains = map.containsKey("Apple");
System.out.println("Contains key 'Apple': " + contains);

boolean containsValue = map.containsValue(50);
System.out.println("Contains value 50: " + containsValue);

int size = map.size();
System.out.println("Size of the map: " + size);

boolean isEmpty = map.isEmpty();
System.out.println("Is the map empty: " + isEmpty);

map.clear();
System.out.println("Size after clear: " + map.size());

import java.util.*;

public class AlgorithmChallenge {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 7, 1);
        Collections.sort(numbers, (a, b) -> b - a);

        int sum = 0;
        for (int i = 0; i < numbers.size(); i++) {
            if (i % 2 == 0) {
                sum += numbers.get(i) * 2;
            } else {
                sum -= numbers.get(i) * 3;
            }
        }
        System.out.println("Result: " + sum);
    }
}

import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<String, String> map = new WeakHashMap<>();

        String key1 = new String("key1");
        String value1 = "value1";
        map.put(key1, value1);

        String key2 = new String("key2");
        String value2 = "value2";
        map.put(key2, value2);

        System.out.println("Map before GC: " + map);

        // Убираем жесткие ссылки на ключи
        key1 = null;
        key2 = null;

        // Вызываем сборщик мусора
        System.gc();

        // Небольшая задержка для того, чтобы сборщик мусора успел сработать
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Map after GC: " + map);
    }
}

import java.util.WeakHashMap;

public class ImageCache {
    private WeakHashMap<String, byte[]> cache = new WeakHashMap<>();

    public byte[] getImage(String imageName) {
        byte[] image = cache.get(imageName);
        if (image == null) {
            image = loadImageFromDisk(imageName);
            cache.put(imageName, image);
        }
        return image;
    }

    private byte[] loadImageFromDisk(String imageName) {
        // Заглушка для примера, возвращаем пустой массив
        return new byte[0];
    }

    public static void main(String[] args) {
        ImageCache imageCache = new ImageCache();
        byte[] image1 = imageCache.getImage("image1.png");
        byte[] image2 = imageCache.getImage("image2.png");

        System.out.println("Image1 loaded: " + (image1 != null));
        System.out.println("Image2 loaded: " + (image2 != null));
    }
}

import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapExample {
    public static void main(String[] args) {
        Map<String, String> identityMap = new IdentityHashMap<>();

        String key1 = new String("key");
        String key2 = new String("key");

        identityMap.put(key1, "Value 1");
        identityMap.put(key2, "Value 2");

        System.out.println("Size of IdentityHashMap: " + identityMap.size()); // Output: 2
        System.out.println("Value for key1: " + identityMap.get(key1)); // Output: Value 1
        System.out.println("Value for key2: " + identityMap.get(key2)); // Output: Value 2

        // Compare with HashMap
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put(key1, "Value 1");
        hashMap.put(key2, "Value 2");

        System.out.println("Size of HashMap: " + hashMap.size()); // Output: 1
    }
}

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

public class ArrayListChallenge {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        Collections.addAll(numbers, 3, 1, 4, 1, 5, 9, 2, 6, 5);

        int result = 0;
        for (int i = 0; i < numbers.size(); i++) {
            if (i % 2 == 0) {
                result += numbers.get(i);
            } else {
                result -= numbers.get(i);
            }
        }

        System.out.println("Result: " + result);
    }
}

import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapMethodsExample {
    public static void main(String[] args) {
        Map<String, String> identityMap = new IdentityHashMap<>();

        String key1 = new String("key");
        String key2 = new String("key");

        // Метод put
        identityMap.put(key1, "Value 1");
        identityMap.put(key2, "Value 2");

        // Метод get
        System.out.println("Value for key1: " + identityMap.get(key1)); // Output: Value 1
        System.out.println("Value for key2: " + identityMap.get(key2)); // Output: Value 2

        // Метод size
        System.out.println("Size of IdentityHashMap: " + identityMap.size()); // Output: 2

        // Метод containsKey
        System.out.println("Contains key1: " + identityMap.containsKey(key1)); // Output: true
        System.out.println("Contains new key: " + identityMap.containsKey(new String("key"))); // Output: false

        // Метод containsValue
        System.out.println("Contains Value 1: " + identityMap.containsValue("Value 1")); // Output: true

        // Метод remove
        identityMap.remove(key1);
        System.out.println("Size after removing key1: " + identityMap.size()); // Output: 1

        // Методы keySet, values, entrySet
        System.out.println("Keys: " + identityMap.keySet()); // Output: [key2]
        System.out.println("Values: " + identityMap.values()); // Output: [Value 2]
        System.out.println("Entries: " + identityMap.entrySet()); // Output: [key2=Value 2]
    }
}

enum Color {
    RED, GREEN, BLUE;
}

EnumMap<Color, String> colorMap = new EnumMap<>(Color.class);

Map<Color, String> anotherMap = new HashMap<>();
anotherMap.put(Color.RED, "Red Color");
anotherMap.put(Color.GREEN, "Green Color");
EnumMap<Color, String> colorMap = new EnumMap<>(anotherMap);

colorMap.put(Color.RED, "Red Color");
colorMap.put(Color.GREEN, "Green Color");
System.out.println(colorMap); // {RED=Red Color, GREEN=Green Color}

String color = colorMap.get(Color.RED);
System.out.println("Color for RED: " + color); // Color for RED: Red Color

String removedColor = colorMap.remove(Color.GREEN);
System.out.println("Removed color: " + removedColor); // Removed color: Green Color
System.out.println(colorMap); // {RED=Red Color}

boolean containsRed = colorMap.containsKey(Color.RED);
System.out.println("Contains RED: " + containsRed); // Contains RED: true

int size = colorMap.size();
System.out.println("Size of the map: " + size); // Size of the map: 1

colorMap.clear();
System.out.println("Size after clear: " + colorMap.size()); // Size after clear: 0

public class VariableChallenge {
    public static void main(String[] args) {
        long a = 123456789012345L;
        boolean b = true;
        double c = 1.2345;

        double result = (b ? a * c : a / c) + (b && a > 1000000000 ? c : a);

        System.out.println("Result: " + result);
    }
}