Dot Product of Two Sparse Vectors

class SparseVector {
    vector<pair<int,int>> data;     // (index, value), sorted by index
public:
    SparseVector(vector<int>& nums) {
        for (int i = 0; i < (int)nums.size(); ++i)
            if (nums[i] != 0) data.emplace_back(i, nums[i]);
    }

    int dotProduct(SparseVector& vec) {
        int i = 0, j = 0, ans = 0;
        auto& A = data;
        auto& B = vec.data;
        while (i < (int)A.size() && j < (int)B.size()) {
            if (A[i].first == B[j].first) { ans += A[i].second * B[j].second; ++i; ++j; }
            else if (A[i].first < B[j].first) ++i;
            else ++j;
        }
        return ans;
    }
};

type SparseVector struct {
    data [][2]int // (index, value), sorted by index
}

func Constructor(nums []int) SparseVector {
    sv := SparseVector{}
    for i, v := range nums {
        if v != 0 {
            sv.data = append(sv.data, [2]int{i, v})
        }
    }
    return sv
}

func (sv *SparseVector) DotProduct(vec SparseVector) int {
    i, j, ans := 0, 0, 0
    A, B := sv.data, vec.data
    for i < len(A) && j < len(B) {
        switch {
        case A[i][0] == B[j][0]:
            ans += A[i][1] * B[j][1]
            i++
            j++
        case A[i][0] < B[j][0]:
            i++
        default:
            j++
        }
    }
    return ans
}

from typing import List

class SparseVector:
    def __init__(self, nums: List[int]):
        self.data = [(i, v) for i, v in enumerate(nums) if v != 0]

    def dotProduct(self, vec: 'SparseVector') -> int:
        i, j, ans = 0, 0, 0
        A, B = self.data, vec.data
        while i < len(A) and j < len(B):
            if A[i][0] == B[j][0]:
                ans += A[i][1] * B[j][1]
                i += 1
                j += 1
            elif A[i][0] < B[j][0]:
                i += 1
            else:
                j += 1
        return ans

var SparseVector = function(nums) {
    this.data = []; // [index, value], sorted by index
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== 0) this.data.push([i, nums[i]]);
    }
};

SparseVector.prototype.dotProduct = function(vec) {
    let i = 0, j = 0, ans = 0;
    const A = this.data, B = vec.data;
    while (i < A.length && j < B.length) {
        if (A[i][0] === B[j][0]) {
            ans += A[i][1] * B[j][1];
            i++;
            j++;
        } else if (A[i][0] < B[j][0]) {
            i++;
        } else {
            j++;
        }
    }
    return ans;
};

class SparseVector {
    private List<int[]> data; // (index, value), sorted by index

    SparseVector(int[] nums) {
        data = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) data.add(new int[]{i, nums[i]});
        }
    }

    public int dotProduct(SparseVector vec) {
        int i = 0, j = 0, ans = 0;
        List<int[]> A = data, B = vec.data;
        while (i < A.size() && j < B.size()) {
            int[] a = A.get(i), b = B.get(j);
            if (a[0] == b[0]) { ans += a[1] * b[1]; i++; j++; }
            else if (a[0] < b[0]) i++;
            else j++;
        }
        return ans;
    }
}

class SparseVector {
    private data: Array<[number, number]> = []; // [index, value], sorted by index

    constructor(nums: number[]) {
        for (let i = 0; i < nums.length; i++) {
            if (nums[i] !== 0) this.data.push([i, nums[i]]);
        }
    }

    dotProduct(vec: SparseVector): number {
        let i = 0, j = 0, ans = 0;
        const A = this.data, B = vec.data;
        while (i < A.length && j < B.length) {
            if (A[i][0] === B[j][0]) {
                ans += A[i][1] * B[j][1];
                i++;
                j++;
            } else if (A[i][0] < B[j][0]) {
                i++;
            } else {
                j++;
            }
        }
        return ans;
    }
}