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);
    }
}

private final Enum<?>[] keyUniverse;

keyUniverse = keyType.getEnumConstants();

private transient Object[] values;

values = new Object[keyUniverse.length];

enum Color {
    RED, GREEN, BLUE;
}

public class EnumMapExample {
    public static void main(String[] args) {
        EnumMap<Color, String> colorMap = new EnumMap<>(Color.class);

        colorMap.put(Color.RED, "Red Color");
        colorMap.put(Color.GREEN, "Green Color");
        colorMap.put(Color.BLUE, "Blue Color");

        for (Color color : colorMap.keySet()) {
            System.out.println(color + ": " + colorMap.get(color));
        }
    }
}

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

public class EnumMapCounter {
    public static void main(String[] args) {
        EnumMap<Day, Integer> dayCount = new EnumMap<>(Day.class);

        // Инициализация счетчика для каждого дня недели
        for (Day day : Day.values()) {
            dayCount.put(day, 0);
        }

        // Увеличиваем счетчики для некоторых дней
        dayCount.put(Day.MONDAY, dayCount.get(Day.MONDAY) + 1);
        dayCount.put(Day.FRIDAY, dayCount.get(Day.FRIDAY) + 2);
        dayCount.put(Day.SUNDAY, dayCount.get(Day.SUNDAY) + 3);

        // Выводим результаты
        for (Day day : dayCount.keySet()) {
            System.out.println(day + ": " + dayCount.get(day));
        }
    }
}

private transient Object[] elementData;

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = {};
    } else {
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // проверка емкости
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // увеличивается на 50%
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

import java.util.HashMap;

public class HashMapChallenge {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);
        map.put("D", 4);
        map.put("E", 5);

        int result = 0;
        for (String key : map.keySet()) {
            if (key.compareTo("C") < 0) {
                result += map.get(key);
            } else {
                result -= map.get(key);
            }
        }

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