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<>();
// 初期値あり（配列の要素型は int[] のラッパークラスである Integer[] である必要があることに注意）
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)  # インデックス 3 に数値 6 を挿入

# 要素を削除
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);  // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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);  // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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);  // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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:]...)...) // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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) // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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); // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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); // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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); // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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);  // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
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);  // インデックス 3 に数値 6 を挿入

/* 要素を削除 */
nums.remove(3);  // インデックス 3 の要素を削除

# リストをクリア
nums.clear

# 末尾に要素を追加
nums << 1
nums << 3
nums << 2
nums << 5
nums << 4

# 途中に要素を挿入
nums.insert(3, 6) # インデックス 3 に数値 6 を挿入

# 要素を削除
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

# 2 つのリストを連結
nums1: list[int] = [6, 8, 7, 10, 9]
nums += nums1  # リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
vector<int> nums1 = { 6, 8, 7, 10, 9 };
// リスト nums1 を nums の後ろに連結
nums.insert(nums.end(), nums1.begin(), nums1.end());

/* 2 つのリストを連結 */
List<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
nums.addAll(nums1);  // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
List<int> nums1 = [6, 8, 7, 10, 9];
nums.AddRange(nums1);  // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
nums1 := []int{6, 8, 7, 10, 9}
nums = append(nums, nums1...)  // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
let nums1 = [6, 8, 7, 10, 9]
nums.append(contentsOf: nums1) // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
const nums1 = [6, 8, 7, 10, 9];
nums.push(...nums1);  // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
const nums1: number[] = [6, 8, 7, 10, 9];
nums.push(...nums1);  // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
List<int> nums1 = [6, 8, 7, 10, 9];
nums.addAll(nums1);  // リスト nums1 を nums の後ろに連結

/* 2 つのリストを連結 */
let nums1: Vec<i32> = vec![6, 8, 7, 10, 9];
nums.extend(nums1);

// C には組み込みの動的配列がない

/* 2 つのリストを連結 */
val nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()
nums.addAll(nums1)  // リスト nums1 を nums の後ろに連結

# 2 つのリストを連結
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 以降の要素をすべて 1 つ後ろへずらす
        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 より後の要素をすべて 1 つ前に移動する
        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 以降の要素をすべて 1 つ後ろへずらす
        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 より後の要素をすべて 1 つ前に移動する
        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 以降の要素をすべて 1 つ後ろへずらす
        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 より後の要素をすべて 1 つ前に移動する
        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 以降の要素をすべて 1 つ後ろへずらす
        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 より後の要素をすべて 1 つ前に移動する
        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 以降の要素をすべて 1 つ後ろへずらす
    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 より後の要素をすべて 1 つ前に移動する
    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 以降の要素をすべて 1 つ後ろへずらす
        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 より後の要素をすべて 1 つ前に移動する
        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()))
    }
}