238. Array product except self

#include <stdlib.h>

int *productExceptSelf(int *nums, int numsSize, int *returnSize) {
  int *prefixes = (int *)malloc(numsSize * sizeof(int));
  int *suffixes = (int *)malloc(numsSize * sizeof(int));
  int *ans = (int *)malloc(numsSize * sizeof(int));

  prefixes[0] = 1;
  for (int i = 1; i < numsSize; i++)
    prefixes[i] = prefixes[i - 1] * nums[i - 1];

  suffixes[numsSize - 1] = 1;
  for (int i = numsSize - 2; i >= 0; i--)
    suffixes[i] = suffixes[i + 1] * nums[i + 1];

  for (int i = 0; i < numsSize; i++)
    ans[i] = prefixes[i] * suffixes[i];

  free(prefixes);
  free(suffixes);

  *returnSize = numsSize;
  return ans;
}

#include <vector>
using namespace std;

class Solution {
public:
  vector<int> productExceptSelf(vector<int> &nums) {
    vector<int> prefixes(nums.size());
    vector<int> suffixes(nums.size());
    vector<int> ans(nums.size());

    prefixes[0] = 1;
    for (int i = 1; i < nums.size(); i++) {
      prefixes[i] = prefixes[i - 1] * nums[i - 1];
    }

    suffixes[nums.size() - 1] = 1;
    for (int i = nums.size() - 2; i >= 0; i--) {
      suffixes[i] = suffixes[i + 1] * nums[i + 1];
    }

    for (int i = 0; i < nums.size(); i++) {
      ans[i] = prefixes[i] * suffixes[i];
    }

    return ans;
  }
};

package main

func productExceptSelf(nums []int) []int {
    n := len(nums)
    prefixes := make([]int, n)
    suffixes := make([]int, n)
    ans := make([]int, n)

    prefixes[0] = 1
    for i := 1; i < n; i++ {
        prefixes[i] = prefixes[i-1] * nums[i-1]
    }

    suffixes[n-1] = 1
    for i := n - 2; i >= 0; i-- {
        suffixes[i] = suffixes[i+1] * nums[i+1]
    }

    for i := 0; i < n; i++ {
        ans[i] = prefixes[i] * suffixes[i]
    }

    return ans
}

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int[] prefixes = new int[n];
        int[] suffixes = new int[n];
        int[] ans = new int[n];

        prefixes[0] = 1;
        for (int i = 1; i < n; i++)
            prefixes[i] = prefixes[i - 1] * nums[i - 1];

        suffixes[n - 1] = 1;
        for (int i = n - 2; i >= 0; i--)
            suffixes[i] = suffixes[i + 1] * nums[i + 1];

        for (int i = 0; i < n; i++)
            ans[i] = prefixes[i] * suffixes[i];

        return ans;
    }
}

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var productExceptSelf = function (nums) {
  const n = nums.length;
  const prefixes = new Array(n);
  const suffixes = new Array(n);
  const ans = new Array(n);

  prefixes[0] = 1;
  for (let i = 1; i < n; i++) prefixes[i] = prefixes[i - 1] * nums[i - 1];

  suffixes[n - 1] = 1;
  for (let i = n - 2; i >= 0; i--) suffixes[i] = suffixes[i + 1] * nums[i + 1];

  for (let i = 0; i < n; i++) ans[i] = prefixes[i] * suffixes[i];

  return ans;
};

class Solution:
    def productExceptSelf(self, nums: list[int]) -> list[int]:
        n = len(nums)
        prefixes = [1] * n
        suffixes = [1] * n
        ans = [1] * n

        for i in range(1, n):
            prefixes[i] = prefixes[i - 1] * nums[i - 1]

        for i in range(n - 2, -1, -1):
            suffixes[i] = suffixes[i + 1] * nums[i + 1]

        for i in range(n):
            ans[i] = prefixes[i] * suffixes[i]

        return ans

impl Solution {
    pub fn product_except_self(nums: Vec<i32>) -> Vec<i32> {
        let n = nums.len();
        let mut prefixes = vec![1; n];
        let mut suffixes = vec![1; n];
        let mut ans = vec![1; n];

        for i in 1..n {
            prefixes[i] = prefixes[i - 1] * nums[i - 1];
        }

        for i in (0..n - 1).rev() {
            suffixes[i] = suffixes[i + 1] * nums[i + 1];
        }

        for i in 0..n {
            ans[i] = prefixes[i] * suffixes[i];
        }

        ans
    }
}