1.python 解法：构建两个函数，主函数轮询每一个元素并调用子函数，子函数用于构建每一个元素的乘积。得益于python的列表解析式，整个解法相对简洁 
# -*- coding:utf-8 -*-
class Solution:
    def multiply(self, A):
        # write code here
        res_lst = []
        [res_lst.append(self.sp_mutil(A, index, A[0])) for index in range(len(A))]
        return res_lst
    
    def sp_mutil(self, lst, index, res):
        for i in range(1, len(lst)):
            if i != index:
                res *= lst[i]
        return res

2.java解法：同python。大括号和分号真的很麻烦且没必要 
import java.util.ArrayList;
public class Solution {
    public int[] multiply(int[] A) {
        int[] res = new int[A.length];
        for(int i=0; i<A.length; i++){
            res[i] = sp_mutil(A, i, A[0]);
        }
        return res;
    }
    private int sp_mutil(int[] lst, int index, int res){
        for(int i=0; i<lst.length;i++){
            if(i!=index){
                res *= lst[i];
            }
        }
        return res;
    }
}

3.go解法：通过轮询数组同时将轮询到的值暂时置为1，计算乘积后再复原。相对上两种解法少了子函数每一次对下标是否是index的判断，更优 
package main

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 
 * @param A int整型一维数组 
 * @return int整型一维数组
*/
func multiply( A []int ) []int {
    // write code here
    var B = make([]int, len(A))
    for i,_ := range(A){
        temp := A[i]
        B[i] = 1
        A[i] = 1
        for k,_ := range(A){
            B[i] *= A[k]
        }
        A[i] = temp
    }
    return B
}