4.3   Список¶

# Инициализация списка
# Без начальных значений
nums1: list[int] = []
# С начальными значениями
nums: list[int] = [1, 3, 2, 5, 4]

/* Инициализация списка */
// Обрати внимание: в C++ vector соответствует описываемому здесь nums
// Без начальных значений
vector<int> nums1;
// С начальными значениями
vector<int> nums = { 1, 3, 2, 5, 4 };

/* Инициализация списка */
// Без начальных значений
List<Integer> nums1 = new ArrayList<>();
// С начальными значениями (обрати внимание: элементы массива должны использовать обертку Integer[] вместо int[])
Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
List<Integer> nums = new ArrayList<>(Arrays.asList(numbers));

/* Инициализация списка */
// Без начальных значений
List<int> nums1 = [];
// С начальными значениями
int[] numbers = [1, 3, 2, 5, 4];
List<int> nums = [.. numbers];

/* Инициализация списка */
// Без начальных значений
nums1 := []int{}
// С начальными значениями
nums := []int{1, 3, 2, 5, 4}

/* Инициализация списка */
// Без начальных значений
let nums1: [Int] = []
// С начальными значениями
var nums = [1, 3, 2, 5, 4]

/* Инициализация списка */
// Без начальных значений
const nums1 = [];
// С начальными значениями
const nums = [1, 3, 2, 5, 4];

/* Инициализация списка */
// Без начальных значений
const nums1: number[] = [];
// С начальными значениями
const nums: number[] = [1, 3, 2, 5, 4];

/* Инициализация списка */
// Без начальных значений
List<int> nums1 = [];
// С начальными значениями
List<int> nums = [1, 3, 2, 5, 4];

/* Инициализация списка */
// Без начальных значений
let nums1: Vec<i32> = Vec::new();
// С начальными значениями
let nums: Vec<i32> = vec![1, 3, 2, 5, 4];

// В C нет встроенного динамического массива

/* Инициализация списка */
// Без начальных значений
var nums1 = listOf<Int>()
// С начальными значениями
var numbers = arrayOf(1, 3, 2, 5, 4)
var nums = numbers.toMutableList()

# Инициализация списка
# Без начальных значений
nums1 = []
# С начальными значениями
nums = [1, 3, 2, 5, 4]

# Доступ к элементу
num: int = nums[1]  # Доступ к элементу по индексу 1

# Обновление элемента
nums[1] = 0    # Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
int num = nums[1];  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0;  // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
int num = nums.get(1);  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums.set(1, 0);  // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
int num = nums[1];  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0;  // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
num := nums[1]  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0     // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
let num = nums[1] // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0 // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
const num = nums[1];  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0;  // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
const num: number = nums[1];  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0;  // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
int num = nums[1];  // Доступ к элементу по индексу 1

/* Обновление элемента */
nums[1] = 0;  // Обновить элемент по индексу 1 значением 0

/* Доступ к элементу */
let num: i32 = nums[1];  // Доступ к элементу по индексу 1
/* Обновление элемента */
nums[1] = 0;             // Обновить элемент по индексу 1 значением 0

// В C нет встроенного динамического массива

/* Доступ к элементу */
val num = nums[1]       // Доступ к элементу по индексу 1
/* Обновление элемента */
nums[1] = 0             // Обновить элемент по индексу 1 значением 0

# Доступ к элементу
num = nums[1] # Доступ к элементу по индексу 1
# Обновление элемента
nums[1] = 0 # Обновить элемент по индексу 1 значением 0

# Очистить список
nums.clear()

# Добавить элементы в конец
nums.append(1)
nums.append(3)
nums.append(2)
nums.append(5)
nums.append(4)

# Вставить элемент в середину
nums.insert(3, 6)  # Вставить число 6 по индексу 3

# Удалить элемент
nums.pop(3)        # Удалить элемент по индексу 3

/* Очистить список */
nums.clear();

/* Добавить элементы в конец */
nums.push_back(1);
nums.push_back(3);
nums.push_back(2);
nums.push_back(5);
nums.push_back(4);

/* Вставить элемент в середину */
nums.insert(nums.begin() + 3, 6);  // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.erase(nums.begin() + 3);      // Удалить элемент по индексу 3

/* Очистить список */
nums.clear();

/* Добавить элементы в конец */
nums.add(1);
nums.add(3);
nums.add(2);
nums.add(5);
nums.add(4);

/* Вставить элемент в середину */
nums.add(3, 6);  // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.remove(3);  // Удалить элемент по индексу 3

/* Очистить список */
nums.Clear();

/* Добавить элементы в конец */
nums.Add(1);
nums.Add(3);
nums.Add(2);
nums.Add(5);
nums.Add(4);

/* Вставить элемент в середину */
nums.Insert(3, 6);  // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.RemoveAt(3);  // Удалить элемент по индексу 3

/* Очистить список */
nums = nil

/* Добавить элементы в конец */
nums = append(nums, 1)
nums = append(nums, 3)
nums = append(nums, 2)
nums = append(nums, 5)
nums = append(nums, 4)

/* Вставить элемент в середину */
nums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Вставить число 6 по индексу 3

/* Удалить элемент */
nums = append(nums[:3], nums[4:]...) // Удалить элемент по индексу 3

/* Очистить список */
nums.removeAll()

/* Добавить элементы в конец */
nums.append(1)
nums.append(3)
nums.append(2)
nums.append(5)
nums.append(4)

/* Вставить элемент в середину */
nums.insert(6, at: 3) // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.remove(at: 3) // Удалить элемент по индексу 3

/* Очистить список */
nums.length = 0;

/* Добавить элементы в конец */
nums.push(1);
nums.push(3);
nums.push(2);
nums.push(5);
nums.push(4);

/* Вставить элемент в середину */
nums.splice(3, 0, 6); // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.splice(3, 1);  // Удалить элемент по индексу 3

/* Очистить список */
nums.length = 0;

/* Добавить элементы в конец */
nums.push(1);
nums.push(3);
nums.push(2);
nums.push(5);
nums.push(4);

/* Вставить элемент в середину */
nums.splice(3, 0, 6); // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.splice(3, 1);  // Удалить элемент по индексу 3

/* Очистить список */
nums.clear();

/* Добавить элементы в конец */
nums.add(1);
nums.add(3);
nums.add(2);
nums.add(5);
nums.add(4);

/* Вставить элемент в середину */
nums.insert(3, 6); // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.removeAt(3); // Удалить элемент по индексу 3

/* Очистить список */
nums.clear();

/* Добавить элементы в конец */
nums.push(1);
nums.push(3);
nums.push(2);
nums.push(5);
nums.push(4);

/* Вставить элемент в середину */
nums.insert(3, 6);  // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.remove(3);    // Удалить элемент по индексу 3

// В C нет встроенного динамического массива

/* Очистить список */
nums.clear();

/* Добавить элементы в конец */
nums.add(1);
nums.add(3);
nums.add(2);
nums.add(5);
nums.add(4);

/* Вставить элемент в середину */
nums.add(3, 6);  // Вставить число 6 по индексу 3

/* Удалить элемент */
nums.remove(3);  // Удалить элемент по индексу 3

# Очистить список
nums.clear

# Добавить элементы в конец
nums << 1
nums << 3
nums << 2
nums << 5
nums << 4

# Вставить элемент в середину
nums.insert(3, 6) # Вставить число 6 по индексу 3

# Удалить элемент
nums.delete_at(3) # Удалить элемент по индексу 3

# Обход списка по индексам
count = 0
for i in range(len(nums)):
    count += nums[i]

# Прямой обход элементов списка
for num in nums:
    count += num

/* Обход списка по индексам */
int count = 0;
for (int i = 0; i < nums.size(); i++) {
    count += nums[i];
}

/* Прямой обход элементов списка */
count = 0;
for (int num : nums) {
    count += num;
}

/* Обход списка по индексам */
int count = 0;
for (int i = 0; i < nums.size(); i++) {
    count += nums.get(i);
}

/* Прямой обход элементов списка */
for (int num : nums) {
    count += num;
}

/* Обход списка по индексам */
int count = 0;
for (int i = 0; i < nums.Count; i++) {
    count += nums[i];
}

/* Прямой обход элементов списка */
count = 0;
foreach (int num in nums) {
    count += num;
}

/* Обход списка по индексам */
count := 0
for i := 0; i < len(nums); i++ {
    count += nums[i]
}

/* Прямой обход элементов списка */
count = 0
for _, num := range nums {
    count += num
}

/* Обход списка по индексам */
var count = 0
for i in nums.indices {
    count += nums[i]
}

/* Прямой обход элементов списка */
count = 0
for num in nums {
    count += num
}

/* Обход списка по индексам */
let count = 0;
for (let i = 0; i < nums.length; i++) {
    count += nums[i];
}

/* Прямой обход элементов списка */
count = 0;
for (const num of nums) {
    count += num;
}

/* Обход списка по индексам */
let count = 0;
for (let i = 0; i < nums.length; i++) {
    count += nums[i];
}

/* Прямой обход элементов списка */
count = 0;
for (const num of nums) {
    count += num;
}

/* Обход списка по индексам */
int count = 0;
for (var i = 0; i < nums.length; i++) {
    count += nums[i];
}

/* Прямой обход элементов списка */
count = 0;
for (var num in nums) {
    count += num;
}

// Обход списка по индексам
let mut _count = 0;
for i in 0..nums.len() {
    _count += nums[i];
}

// Прямой обход элементов списка
_count = 0;
for num in &nums {
    _count += num;
}

// В C нет встроенного динамического массива

/* Обход списка по индексам */
var count = 0
for (i in nums.indices) {
    count += nums[i]
}

/* Прямой обход элементов списка */
for (num in nums) {
    count += num
}

# Обход списка по индексам
count = 0
for i in 0...nums.length
    count += nums[i]
end

# Прямой обход элементов списка
count = 0
for num in nums
    count += num
end

# Конкатенация двух списков
nums1: list[int] = [6, 8, 7, 10, 9]
nums += nums1  # Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
vector<int> nums1 = { 6, 8, 7, 10, 9 };
// Присоединить список nums1 к концу nums
nums.insert(nums.end(), nums1.begin(), nums1.end());

/* Конкатенация двух списков */
List<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
nums.addAll(nums1);  // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
List<int> nums1 = [6, 8, 7, 10, 9];
nums.AddRange(nums1);  // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
nums1 := []int{6, 8, 7, 10, 9}
nums = append(nums, nums1...)  // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
let nums1 = [6, 8, 7, 10, 9]
nums.append(contentsOf: nums1) // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
const nums1 = [6, 8, 7, 10, 9];
nums.push(...nums1);  // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
const nums1: number[] = [6, 8, 7, 10, 9];
nums.push(...nums1);  // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
List<int> nums1 = [6, 8, 7, 10, 9];
nums.addAll(nums1);  // Присоединить список nums1 к концу nums

/* Конкатенация двух списков */
let nums1: Vec<i32> = vec![6, 8, 7, 10, 9];
nums.extend(nums1);

// В C нет встроенного динамического массива

/* Конкатенация двух списков */
val nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()
nums.addAll(nums1)  // Присоединить список nums1 к концу nums

# Конкатенация двух списков
nums1 = [6, 8, 7, 10, 9]
nums += nums1

# Отсортировать список
nums.sort()  # После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
sort(nums.begin(), nums.end());  // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
Collections.sort(nums);  // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
nums.Sort(); // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
sort.Ints(nums)  // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
nums.sort() // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
nums.sort((a, b) => a - b);  // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
nums.sort((a, b) => a - b);  // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
nums.sort(); // После сортировки элементы списка идут по возрастанию

/* Отсортировать список */
nums.sort(); // После сортировки элементы списка идут по возрастанию

// В C нет встроенного динамического массива

/* Отсортировать список */
nums.sort() // После сортировки элементы списка идут по возрастанию

# Отсортировать список
nums = nums.sort { |a, b| a <=> b } # После сортировки элементы списка идут по возрастанию

class MyList:
    """Класс списка"""

    def __init__(self):
        """Конструктор"""
        self._capacity: int = 10  # Вместимость списка
        self._arr: list[int] = [0] * self._capacity  # Массив (для хранения элементов списка)
        self._size: int = 0  # Длина списка (текущее число элементов)
        self._extend_ratio: int = 2  # Коэффициент увеличения списка при каждом расширении

    def size(self) -> int:
        """Получить длину списка (текущее число элементов)"""
        return self._size

    def capacity(self) -> int:
        """Получить вместимость списка"""
        return self._capacity

    def get(self, index: int) -> int:
        """Доступ к элементу"""
        # Если индекс выходит за границы, выбрасывается исключение; далее аналогично
        if index < 0 or index >= self._size:
            raise IndexError("индекс выходит за границы")
        return self._arr[index]

    def set(self, num: int, index: int):
        """Обновление элемента"""
        if index < 0 or index >= self._size:
            raise IndexError("индекс выходит за границы")
        self._arr[index] = num

    def add(self, num: int):
        """Добавление элемента в конец"""
        # При превышении вместимости по числу элементов запускается расширение
        if self.size() == self.capacity():
            self.extend_capacity()
        self._arr[self._size] = num
        self._size += 1

    def insert(self, num: int, index: int):
        """Вставка элемента в середину"""
        if index < 0 or index >= self._size:
            raise IndexError("индекс выходит за границы")
        # При превышении вместимости по числу элементов запускается расширение
        if self._size == self.capacity():
            self.extend_capacity()
        # Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
        for j in range(self._size - 1, index - 1, -1):
            self._arr[j + 1] = self._arr[j]
        self._arr[index] = num
        # Обновить число элементов
        self._size += 1

    def remove(self, index: int) -> int:
        """Удаление элемента"""
        if index < 0 or index >= self._size:
            raise IndexError("индекс выходит за границы")
        num = self._arr[index]
        # Сдвинуть все элементы после индекса index на одну позицию вперед
        for j in range(index, self._size - 1):
            self._arr[j] = self._arr[j + 1]
        # Обновить число элементов
        self._size -= 1
        # Вернуть удаленный элемент
        return num

    def extend_capacity(self):
        """Расширение списка"""
        # Создать новый массив длиной в _extend_ratio раз больше исходного массива и скопировать в него исходный массив
        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)
        # Обновить вместимость списка
        self._capacity = len(self._arr)

    def to_array(self) -> list[int]:
        """Вернуть список фактической длины"""
        return self._arr[: self._size]

/* Класс списка */
class MyList {
  private:
    int *arr;             // Массив (для хранения элементов списка)
    int arrCapacity = 10; // Вместимость списка
    int arrSize = 0;      // Длина списка (текущее число элементов)
    int extendRatio = 2;   // Коэффициент увеличения списка при каждом расширении

  public:
    /* Конструктор */
    MyList() {
        arr = new int[arrCapacity];
    }

    /* Метод-деструктор */
    ~MyList() {
        delete[] arr;
    }

    /* Получить длину списка (текущее число элементов) */
    int size() {
        return arrSize;
    }

    /* Получить вместимость списка */
    int capacity() {
        return arrCapacity;
    }

    /* Доступ к элементу */
    int get(int index) {
        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
        if (index < 0 || index >= size())
            throw out_of_range("индекс выходит за границы");
        return arr[index];
    }

    /* Обновление элемента */
    void set(int index, int num) {
        if (index < 0 || index >= size())
            throw out_of_range("индекс выходит за границы");
        arr[index] = num;
    }

    /* Добавление элемента в конец */
    void add(int num) {
        // При превышении вместимости по числу элементов запускается расширение
        if (size() == capacity())
            extendCapacity();
        arr[size()] = num;
        // Обновить число элементов
        arrSize++;
    }

    /* Вставка элемента в середину */
    void insert(int index, int num) {
        if (index < 0 || index >= size())
            throw out_of_range("индекс выходит за границы");
        // При превышении вместимости по числу элементов запускается расширение
        if (size() == capacity())
            extendCapacity();
        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
        for (int j = size() - 1; j >= index; j--) {
            arr[j + 1] = arr[j];
        }
        arr[index] = num;
        // Обновить число элементов
        arrSize++;
    }

    /* Удаление элемента */
    int remove(int index) {
        if (index < 0 || index >= size())
            throw out_of_range("индекс выходит за границы");
        int num = arr[index];
        // Сдвинуть все элементы после индекса index на одну позицию вперед
        for (int j = index; j < size() - 1; j++) {
            arr[j] = arr[j + 1];
        }
        // Обновить число элементов
        arrSize--;
        // Вернуть удаленный элемент
        return num;
    }

    /* Расширение списка */
    void extendCapacity() {
        // Создать новый массив длиной в extendRatio раз больше исходного массива
        int newCapacity = capacity() * extendRatio;
        int *tmp = arr;
        arr = new int[newCapacity];
        // Скопировать все элементы исходного массива в новый массив
        for (int i = 0; i < size(); i++) {
            arr[i] = tmp[i];
        }
        // Освободить память
        delete[] tmp;
        arrCapacity = newCapacity;
    }

    /* Преобразовать список в Vector для вывода */
    vector<int> toVector() {
        // Преобразовывать только элементы списка в пределах фактической длины
        vector<int> vec(size());
        for (int i = 0; i < size(); i++) {
            vec[i] = arr[i];
        }
        return vec;
    }
};

/* Класс списка */
class MyList {
    private int[] arr; // Массив (для хранения элементов списка)
    private int capacity = 10; // Вместимость списка
    private int size = 0; // Длина списка (текущее число элементов)
    private int extendRatio = 2; // Коэффициент увеличения списка при каждом расширении

    /* Конструктор */
    public MyList() {
        arr = new int[capacity];
    }

    /* Получить длину списка (текущее число элементов) */
    public int size() {
        return size;
    }

    /* Получить вместимость списка */
    public int capacity() {
        return capacity;
    }

    /* Доступ к элементу */
    public int get(int index) {
        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("индекс выходит за границы");
        return arr[index];
    }

    /* Обновление элемента */
    public void set(int index, int num) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("индекс выходит за границы");
        arr[index] = num;
    }

    /* Добавление элемента в конец */
    public void add(int num) {
        // При превышении вместимости по числу элементов запускается расширение
        if (size == capacity())
            extendCapacity();
        arr[size] = num;
        // Обновить число элементов
        size++;
    }

    /* Вставка элемента в середину */
    public void insert(int index, int num) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("индекс выходит за границы");
        // При превышении вместимости по числу элементов запускается расширение
        if (size == capacity())
            extendCapacity();
        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
        for (int j = size - 1; j >= index; j--) {
            arr[j + 1] = arr[j];
        }
        arr[index] = num;
        // Обновить число элементов
        size++;
    }

    /* Удаление элемента */
    public int remove(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("индекс выходит за границы");
        int num = arr[index];
        // Сдвинуть все элементы после индекса index на одну позицию вперед
        for (int j = index; j < size - 1; j++) {
            arr[j] = arr[j + 1];
        }
        // Обновить число элементов
        size--;
        // Вернуть удаленный элемент
        return num;
    }

    /* Расширение списка */
    public void extendCapacity() {
        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив
        arr = Arrays.copyOf(arr, capacity() * extendRatio);
        // Обновить вместимость списка
        capacity = arr.length;
    }

    /* Преобразовать список в массив */
    public int[] toArray() {
        int size = size();
        // Преобразовывать только элементы списка в пределах фактической длины
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = get(i);
        }
        return arr;
    }
}

/* Класс списка */
class MyList {
    private int[] arr;           // Массив (для хранения элементов списка)
    private int arrCapacity = 10;    // Вместимость списка
    private int arrSize = 0;         // Длина списка (текущее число элементов)
    private readonly int extendRatio = 2;  // Коэффициент увеличения списка при каждом расширении

    /* Конструктор */
    public MyList() {
        arr = new int[arrCapacity];
    }

    /* Получить длину списка (текущее число элементов) */
    public int Size() {
        return arrSize;
    }

    /* Получить вместимость списка */
    public int Capacity() {
        return arrCapacity;
    }

    /* Доступ к элементу */
    public int Get(int index) {
        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
        if (index < 0 || index >= arrSize)
            throw new IndexOutOfRangeException("индекс выходит за границы");
        return arr[index];
    }

    /* Обновление элемента */
    public void Set(int index, int num) {
        if (index < 0 || index >= arrSize)
            throw new IndexOutOfRangeException("индекс выходит за границы");
        arr[index] = num;
    }

    /* Добавление элемента в конец */
    public void Add(int num) {
        // При превышении вместимости по числу элементов запускается расширение
        if (arrSize == arrCapacity)
            ExtendCapacity();
        arr[arrSize] = num;
        // Обновить число элементов
        arrSize++;
    }

    /* Вставка элемента в середину */
    public void Insert(int index, int num) {
        if (index < 0 || index >= arrSize)
            throw new IndexOutOfRangeException("индекс выходит за границы");
        // При превышении вместимости по числу элементов запускается расширение
        if (arrSize == arrCapacity)
            ExtendCapacity();
        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
        for (int j = arrSize - 1; j >= index; j--) {
            arr[j + 1] = arr[j];
        }
        arr[index] = num;
        // Обновить число элементов
        arrSize++;
    }

    /* Удаление элемента */
    public int Remove(int index) {
        if (index < 0 || index >= arrSize)
            throw new IndexOutOfRangeException("индекс выходит за границы");
        int num = arr[index];
        // Сдвинуть все элементы после индекса index на одну позицию вперед
        for (int j = index; j < arrSize - 1; j++) {
            arr[j] = arr[j + 1];
        }
        // Обновить число элементов
        arrSize--;
        // Вернуть удаленный элемент
        return num;
    }

    /* Расширение списка */
    public void ExtendCapacity() {
        // Создать новый массив длиной arrCapacity * extendRatio и скопировать в него исходный массив
        Array.Resize(ref arr, arrCapacity * extendRatio);
        // Обновить вместимость списка
        arrCapacity = arr.Length;
    }

    /* Преобразовать список в массив */
    public int[] ToArray() {
        // Преобразовывать только элементы списка в пределах фактической длины
        int[] arr = new int[arrSize];
        for (int i = 0; i < arrSize; i++) {
            arr[i] = Get(i);
        }
        return arr;
    }
}

/* Класс списка */
type myList struct {
    arrCapacity int
    arr         []int
    arrSize     int
    extendRatio int
}

/* Конструктор */
func newMyList() *myList {
    return &myList{
        arrCapacity: 10,              // Вместимость списка
        arr:         make([]int, 10), // Массив (для хранения элементов списка)
        arrSize:     0,               // Длина списка (текущее число элементов)
        extendRatio: 2,               // Коэффициент увеличения списка при каждом расширении
    }
}

/* Получить длину списка (текущее число элементов) */
func (l *myList) size() int {
    return l.arrSize
}

/* Получить вместимость списка */
func (l *myList) capacity() int {
    return l.arrCapacity
}

/* Доступ к элементу */
func (l *myList) get(index int) int {
    // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
    if index < 0 || index >= l.arrSize {
        panic("индекс выходит за границы")
    }
    return l.arr[index]
}

/* Обновление элемента */
func (l *myList) set(num, index int) {
    if index < 0 || index >= l.arrSize {
        panic("индекс выходит за границы")
    }
    l.arr[index] = num
}

/* Добавление элемента в конец */
func (l *myList) add(num int) {
    // При превышении вместимости по числу элементов запускается расширение
    if l.arrSize == l.arrCapacity {
        l.extendCapacity()
    }
    l.arr[l.arrSize] = num
    // Обновить число элементов
    l.arrSize++
}

/* Вставка элемента в середину */
func (l *myList) insert(num, index int) {
    if index < 0 || index >= l.arrSize {
        panic("индекс выходит за границы")
    }
    // При превышении вместимости по числу элементов запускается расширение
    if l.arrSize == l.arrCapacity {
        l.extendCapacity()
    }
    // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
    for j := l.arrSize - 1; j >= index; j-- {
        l.arr[j+1] = l.arr[j]
    }
    l.arr[index] = num
    // Обновить число элементов
    l.arrSize++
}

/* Удаление элемента */
func (l *myList) remove(index int) int {
    if index < 0 || index >= l.arrSize {
        panic("индекс выходит за границы")
    }
    num := l.arr[index]
    // Сдвинуть все элементы после индекса index на одну позицию вперед
    for j := index; j < l.arrSize-1; j++ {
        l.arr[j] = l.arr[j+1]
    }
    // Обновить число элементов
    l.arrSize--
    // Вернуть удаленный элемент
    return num
}

/* Расширение списка */
func (l *myList) extendCapacity() {
    // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив
    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)
    // Обновить вместимость списка
    l.arrCapacity = len(l.arr)
}

/* Вернуть список фактической длины */
func (l *myList) toArray() []int {
    // Преобразовывать только элементы списка в пределах фактической длины
    return l.arr[:l.arrSize]
}

/* Класс списка */
class MyList {
    private var arr: [Int] // Массив (для хранения элементов списка)
    private var _capacity: Int // Вместимость списка
    private var _size: Int // Длина списка (текущее число элементов)
    private let extendRatio: Int // Коэффициент увеличения списка при каждом расширении

    /* Конструктор */
    init() {
        _capacity = 10
        _size = 0
        extendRatio = 2
        arr = Array(repeating: 0, count: _capacity)
    }

    /* Получить длину списка (текущее число элементов) */
    func size() -> Int {
        _size
    }

    /* Получить вместимость списка */
    func capacity() -> Int {
        _capacity
    }

    /* Доступ к элементу */
    func get(index: Int) -> Int {
        // Если индекс выходит за границы, выбросить ошибку; далее аналогично
        if index < 0 || index >= size() {
            fatalError("индекс выходит за границы")
        }
        return arr[index]
    }

    /* Обновление элемента */
    func set(index: Int, num: Int) {
        if index < 0 || index >= size() {
            fatalError("индекс выходит за границы")
        }
        arr[index] = num
    }

    /* Добавление элемента в конец */
    func add(num: Int) {
        // При превышении вместимости по числу элементов запускается расширение
        if size() == capacity() {
            extendCapacity()
        }
        arr[size()] = num
        // Обновить число элементов
        _size += 1
    }

    /* Вставка элемента в середину */
    func insert(index: Int, num: Int) {
        if index < 0 || index >= size() {
            fatalError("индекс выходит за границы")
        }
        // При превышении вместимости по числу элементов запускается расширение
        if size() == capacity() {
            extendCapacity()
        }
        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
        for j in (index ..< size()).reversed() {
            arr[j + 1] = arr[j]
        }
        arr[index] = num
        // Обновить число элементов
        _size += 1
    }

    /* Удаление элемента */
    @discardableResult
    func remove(index: Int) -> Int {
        if index < 0 || index >= size() {
            fatalError("индекс выходит за границы")
        }
        let num = arr[index]
        // Сдвинуть все элементы после индекса index на одну позицию вперед
        for j in index ..< (size() - 1) {
            arr[j] = arr[j + 1]
        }
        // Обновить число элементов
        _size -= 1
        // Вернуть удаленный элемент
        return num
    }

    /* Расширение списка */
    func extendCapacity() {
        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив
        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))
        // Обновить вместимость списка
        _capacity = arr.count
    }

    /* Преобразовать список в массив */
    func toArray() -> [Int] {
        Array(arr.prefix(size()))
    }
}