숫자 배열이 주어지면 다른 모든 숫자의 제품 배열을 반환하십시오 (나눗셈 없음)

면접에서이 질문을 받았고 다른 사람들이 어떻게 해결할 수 있는지 알고 싶습니다. Java에 가장 익숙하지만 다른 언어로 된 솔루션도 환영합니다.

숫자의 배열을 지정해, nums숫자의 배열 반환 products, products[i]모두의 제품입니다 nums[j], j != i.

Input : [1, 2, 3, 4, 5]
Output: [(2*3*4*5), (1*3*4*5), (1*2*4*5), (1*2*3*5), (1*2*3*4)]
      = [120, 60, 40, 30, 24]

O(N)나누기를 사용하지 않고이 작업을 수행해야합니다 .

polygenelubricants 방법에 대한 설명 은 다음과 같습니다. 트릭은 배열을 구성하는 것입니다 (4 가지 요소의 경우).

{              1,         a[0],    a[0]*a[1],    a[0]*a[1]*a[2],  }
{ a[1]*a[2]*a[3],    a[2]*a[3],         a[3],                 1,  }

둘 다 왼쪽과 오른쪽 가장자리에서 각각 시작하여 O (n)에서 수행 할 수 있습니다.

그런 다음 두 배열 요소에 요소를 곱하면 필요한 결과가 나타납니다.

내 코드는 다음과 같습니다.

int a[N] // This is the input
int products_below[N];
p=1;
for(int i=0;i<N;++i) {
  products_below[i]=p;
  p*=a[i];
}

int products_above[N];
p=1;
for(int i=N-1;i>=0;--i) {
  products_above[i]=p;
  p*=a[i];
}

int products[N]; // This is the result
for(int i=0;i<N;++i) {
  products[i]=products_below[i]*products_above[i];
}

우주에서 O (1)이되어야한다면 이렇게 할 수 있습니다 (IMHO가 덜 명확합니다)

int a[N] // This is the input
int products[N];

// Get the products below the current index
p=1;
for(int i=0;i<N;++i) {
  products[i]=p;
  p*=a[i];
}

// Get the products above the curent index
p=1;
for(int i=N-1;i>=0;--i) {
  products[i]*=p;
  p*=a[i];
}

다음은 modofication을 수행하는 작은 재귀 함수 (C ++)입니다. 그래도 O (n) 여분의 공간 (스택)이 필요합니다. 배열이 a에 있고 N이 배열 길이를 보유한다고 가정하면

int multiply(int *a, int fwdProduct, int indx) {
    int revProduct = 1;
    if (indx < N) {
       revProduct = multiply(a, fwdProduct*a[indx], indx+1);
       int cur = a[indx];
       a[indx] = fwdProduct * revProduct;
       revProduct *= cur;
    }
    return revProduct;
}

Java로 해결하려는 나의 시도는 다음과 같습니다. 비표준 형식에 대한 사과지만 코드에는 많은 중복이 있으며 이것이 읽기 가능하도록 최선의 방법입니다.

import java.util.Arrays;

public class Products {
    static int[] products(int... nums) {
        final int N = nums.length;
        int[] prods = new int[N];
        Arrays.fill(prods, 1);
        for (int
           i = 0, pi = 1    ,  j = N-1, pj = 1  ;
           (i < N)         && (j >= 0)          ;
           pi *= nums[i++]  ,  pj *= nums[j--]  )
        {
           prods[i] *= pi   ;  prods[j] *= pj   ;
        }
        return prods;
    }
    public static void main(String[] args) {
        System.out.println(
            Arrays.toString(products(1, 2, 3, 4, 5))
        ); // prints "[120, 60, 40, 30, 24]"
    }
}

루프 불변량은 pi = nums[0] * nums[1] *.. nums[i-1]및 pj = nums[N-1] * nums[N-2] *.. nums[j+1]입니다. i왼쪽 부분은 "접두사"논리이고, j오른쪽 부분은 "접미사"논리이다.

재귀 원 라이너

Jasmeet 은 (아름다운!) 재귀 솔루션을 제공했습니다. 나는 이것을 (끔찍한!) Java one-liner로 바꾸었다. 그것은 수행 의 장소 수정 과, O(N)스택의 임시 공간.

static int multiply(int[] nums, int p, int n) {
    return (n == nums.length) ? 1
      : nums[n] * (p = multiply(nums, nums[n] * (nums[n] = p), n + 1))
          + 0*(nums[n] *= p);
}

int[] arr = {1,2,3,4,5};
multiply(arr, 1, 0);
System.out.println(Arrays.toString(arr));
// prints "[120, 60, 40, 30, 24]"

Michael Anderson의 솔루션을 Haskell로 번역 :

otherProducts xs = zipWith (*) below above

     where below = scanl (*) 1 $ init xs

           above = tail $ scanr (*) 1 xs

"분열 없음"규칙을 우회적으로 우회 :

sum = 0.0
for i in range(a):
  sum += log(a[i])

for i in range(a):
  output[i] = exp(sum - log(a[i]))

O (N) 복잡성을 가진 간단하고 깨끗한 솔루션입니다.

int[] a = {1,2,3,4,5};
    int[] r = new int[a.length];
    int x = 1;
    r[0] = 1;
    for (int i=1;i<a.length;i++){
        r[i]=r[i-1]*a[i-1];
    }
    for (int i=a.length-1;i>0;i--){
        x=x*a[i];
        r[i-1]=x*r[i-1];
    }
    for (int i=0;i<r.length;i++){
        System.out.println(r[i]);
    }

C ++, O (n) :

long long prod = accumulate(in.begin(), in.end(), 1LL, multiplies<int>());
transform(in.begin(), in.end(), back_inserter(res),
          bind1st(divides<long long>(), prod));

1. 왼쪽으로 이동-> 오른쪽으로 제품을 저장하십시오. 과거라고 불러 -> O (n)
2. 여행 오른쪽-> 왼쪽으로 제품을 보관하십시오. 그것을 미래라고 부릅니다. -> O (n)
3. 결과 [i] = 과거 [i-1] * 미래 [i + 1]-> O (n)
4. 과거 [-1] = 1; 그리고 미래 [n + 1] = 1;

의 위에)

현대 C ++의 솔루션은 다음과 같습니다. 사용합니다std::transform 하고 기억하기가 쉽습니다.

온라인 코드 (wandbox)

#include<algorithm>
#include<iostream>
#include<vector>

using namespace std;

vector<int>& multiply_up(vector<int>& v){
    v.insert(v.begin(),1);
    transform(v.begin()+1, v.end()
             ,v.begin()
             ,v.begin()+1
             ,[](auto const& a, auto const& b) { return b*a; }
             );
    v.pop_back();
    return v;
}

int main() {
    vector<int> v = {1,2,3,4,5};
    auto vr = v;

    reverse(vr.begin(),vr.end());
    multiply_up(v);
    multiply_up(vr);
    reverse(vr.begin(),vr.end());

    transform(v.begin(),v.end()
             ,vr.begin()
             ,v.begin()
             ,[](auto const& a, auto const& b) { return b*a; }
             );

    for(auto& i: v) cout << i << " "; 
}

이것은 O (n ^ 2)이지만 f #은 너무 아름답습니다.

List.fold (fun seed i -> List.mapi (fun j x -> if i=j+1 then x else x*i) seed) 
          [1;1;1;1;1]
          [1..5]

각 요소의 왼쪽과 오른쪽에있는 숫자의 곱을 미리 계산하십시오. 모든 요소에 대해 원하는 값은 neigbors 제품의 제품입니다.

#include <stdio.h>

unsigned array[5] = { 1,2,3,4,5};

int main(void)
{
unsigned idx;

unsigned left[5]
        , right[5];
left[0] = 1;
right[4] = 1;

        /* calculate products of numbers to the left of [idx] */
for (idx=1; idx < 5; idx++) {
        left[idx] = left[idx-1] * array[idx-1];
        }

        /* calculate products of numbers to the right of [idx] */
for (idx=4; idx-- > 0; ) {
        right[idx] = right[idx+1] * array[idx+1];
        }

for (idx=0; idx <5 ; idx++) {
        printf("[%u] Product(%u*%u) = %u\n"
                , idx, left[idx] , right[idx]  , left[idx] * right[idx]  );
        }

return 0;
}

결과:

$ ./a.out
[0] Product(1*120) = 120
[1] Product(1*60) = 60
[2] Product(2*20) = 40
[3] Product(6*5) = 30
[4] Product(24*1) = 24

(업데이트 : 이제 자세히 살펴보면 위의 Michael Anderson, Daniel Migowski 및 polygenelubricants와 동일한 방법을 사용합니다)

교활한:

다음을 사용하십시오.

public int[] calc(int[] params) {

int[] left = new int[n-1]
in[] right = new int[n-1]

int fac1 = 1;
int fac2 = 1;
for( int i=0; i<n; i++ ) {
    fac1 = fac1 * params[i];
    fac2 = fac2 * params[n-i];
    left[i] = fac1;
    right[i] = fac2; 
}
fac = 1;

int[] results = new int[n];
for( int i=0; i<n; i++ ) {
    results[i] = left[i] * right[i];
}

예, i 대신 i-1을 놓쳤다 고 확신하지만 그 방법으로 해결할 수 있습니다.

최적이 아닌 O (N ^ (3/2)) 솔루션도 있습니다. 그래도 꽤 흥미 롭습니다.

먼저 크기 N ^ 0.5의 각 부분 곱셈을 사전 처리합니다 (O (N) 시간 복잡도에서 수행됨). 그런 다음 각 숫자의 다른 값 '배수에 대한 계산은 2 * O (N ^ 0.5) 시간에 수행 할 수 있습니다 (왜? 다른 ((N ^ 0.5)-1) 숫자의 마지막 요소 만 여러 개만 필요하기 때문에, 결과에 ((N ^ 0.5)-1) 현재 숫자의 그룹에 속하는 숫자)를 곱하십시오. 각 숫자에 대해이 작업을 수행하면 O (N ^ (3/2)) 시간을 얻을 수 있습니다.

예:

4 6 7 2 3 1 9 5 8

부분 결과 : 4 * 6 * 7 = 168 2 * 3 * 1 = 6 9 * 5 * 8 = 360

3의 값을 계산하려면 다른 그룹의 값에 168 * 360을 곱한 다음 2 * 1을 곱해야합니다.

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    int[] result = { 1, 1, 1, 1, 1 };
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < i; j++) {
            result[i] *= arr[j];

        }
        for (int k = arr.length - 1; k > i; k--) {
            result[i] *= arr[k];
        }
    }
    for (int i : result) {
        System.out.println(i);
    }
}

이 솔루션은 내가 생각해 냈고 어떻게 생각하는지 분명히 알았습니다!?

def productify(arr, prod, i):
    if i < len(arr):
            prod.append(arr[i - 1] * prod[i - 1]) if i > 0 else prod.append(1)
            retval = productify(arr, prod, i + 1)
            prod[i] *= retval
            return retval * arr[i]
    return 1

arr = [1, 2, 3, 4, 5] prod = [] productify (arr, prod, 0) 인쇄 제품

스칼라의 코드는 다음과 같습니다.

val list1 = List(1, 2, 3, 4, 5)
for (elem <- list1) println(list1.filter(_ != elem) reduceLeft(_*_))

다음이 인쇄됩니다.

120
60
40
30
24

프로그램은 현재 요소를 필터링합니다 (_! = elem). 새 목록에 reduceLeft 메소드를 곱하십시오. 게으른 평가에 scala view 또는 Iterator를 사용하면 이것이 O (n)이 될 것이라고 생각합니다.

Billz 답변을 기반으로합니다. 죄송합니다. 댓글을 달 수는 없지만 목록의 중복 항목을 올바르게 처리하는 스칼라 버전이며 아마도 O (n)입니다.

val list1 = List(1, 7, 3, 3, 4, 4)
val view = list1.view.zipWithIndex map { x => list1.view.patch(x._2, Nil, 1).reduceLeft(_*_)}
view.force

보고:

List(1008, 144, 336, 336, 252, 252)

내가 제안하는 사람을 찾지 못했기 때문에 여기에 내 자바 스크립트 솔루션을 추가하십시오. 다른 숫자에서 숫자를 추출 할 수있는 횟수를 제외하고 나누는 것은 무엇입니까? 전체 배열의 곱을 계산 한 다음 각 요소를 반복하고 0까지 현재 요소를 뺍니다.

//No division operation allowed
// keep substracting divisor from dividend, until dividend is zero or less than divisor
function calculateProducsExceptCurrent_NoDivision(input){
  var res = [];
  var totalProduct = 1;
  //calculate the total product
  for(var i = 0; i < input.length; i++){
    totalProduct = totalProduct * input[i];
  }
  //populate the result array by "dividing" each value
  for(var i = 0; i < input.length; i++){
    var timesSubstracted = 0;
    var divisor = input[i];
    var dividend = totalProduct;
    while(divisor <= dividend){
      dividend = dividend - divisor;
      timesSubstracted++;
    }
    res.push(timesSubstracted);
  }
  return res;
}

C #에 익숙합니다.

    public int[] ProductExceptSelf(int[] nums)
    {
        int[] returnArray = new int[nums.Length];
        List<int> auxList = new List<int>();
        int multTotal = 0;

        // If no zeros are contained in the array you only have to calculate it once
        if(!nums.Contains(0))
        {
            multTotal = nums.ToList().Aggregate((a, b) => a * b);

            for (int i = 0; i < nums.Length; i++)
            {
                returnArray[i] = multTotal / nums[i];
            }
        }
        else
        {
            for (int i = 0; i < nums.Length; i++)
            {
                auxList = nums.ToList();
                auxList.RemoveAt(i);
                if (!auxList.Contains(0))
                {
                    returnArray[i] = auxList.Aggregate((a, b) => a * b);
                }
                else
                {
                    returnArray[i] = 0;
                }
            }
        }            

        return returnArray;
    }

먼저 nums[j](where j != i)를 목록에서 제외 하고 나머지 제품을 얻을 수 있습니다. python way이 퍼즐을 해결하기 위해 다음과 같습니다

from functools import reduce
def products(nums):
    return [ reduce(lambda x,y: x * y, nums[:i] + nums[i+1:]) for i in range(len(nums)) ]
print(products([1, 2, 3, 4, 5]))

[out]
[120, 60, 40, 30, 24]

이 솔루션은 C / C ++의 솔루션으로 간주 될 수 있습니다. a [n]과 같은 n 개의 요소를 포함하는 배열 "a"가 있다고 가정하면 의사 코드는 다음과 같습니다.

for(j=0;j<n;j++)
  { 
    prod[j]=1;

    for (i=0;i<n;i++)
    {   
        if(i==j)
        continue;  
        else
        prod[j]=prod[j]*a[i];
  }

부서를 사용하는 또 하나의 솔루션. 두 번 순회합니다. 모든 요소를 ​​곱한 다음 각 요소로 나누기 시작하십시오.

{-
sqrt (n) 서브 세트를 사용하는 재귀 솔루션. O (n)에서 실행됩니다.

sqrt (n) 크기의 sqrt (n) 서브 세트에 대한 솔루션을 재귀 적으로 계산합니다. 
그런 다음 각 부분 집합의 곱에 따라 반복됩니다.
그런 다음 각 하위 집합의 각 요소에 대해
다른 모든 제품의 제품 합계
그런 다음 모든 하위 세트를 평평하게합니다.

런타임시 반복은 T (n) = sqrt (n) * T (sqrt (n)) + T (sqrt (n)) + n입니다.

O (n)에서 T (n) ≤ cn이라고 가정하십시오.

T (n) = sqrt (n) * T (sqrt (n)) + T (sqrt (n)) + n
    ≤ sqrt (n) * c * sqrt (n) + c * sqrt (n) + n
    ≤ c * n + c * sqrt (n) + n
    ≤ (2c + 1) * n
    ∈ O (n)

ceiling (sqrt (n))은 이진 검색을 사용하여 계산할 수 있습니다. 
sqrt 명령이 허용되지 않는 경우 O (logn) 반복.
-}

otherProducts [] = []
otherProducts [x] = [1]
otherProducts [x, y] = [y, x]
otherProducts a = foldl '(++) [] $ zipWith (\ sp-> map (* p) s) solvedSubsets 서브 세트 OtherProducts
    어디 
      n = 길이 a

      -서브 세트 크기. 1 <s <n이어야합니다.
      s = 상한 $ sqrt $ fromIntegral n

      solvedSubsets = 다른 제품 하위 집합 매핑
      서브셋 OtherProducts = otherProducts $ 맵 제품 서브셋

      하위 집합 = 역 $ 루프 a []
          루프 [] acc = acc
                루프 a acc = 루프 (drop sa) ((take sa) : acc)

내 코드는 다음과 같습니다.

int multiply(int a[],int n,int nextproduct,int i)
{
    int prevproduct=1;
    if(i>=n)
        return prevproduct;
    prevproduct=multiply(a,n,nextproduct*a[i],i+1);
    printf(" i=%d > %d\n",i,prevproduct*nextproduct);
    return prevproduct*a[i];
}

int main()
{
    int a[]={2,4,1,3,5};
    multiply(a,5,1,0);
    return 0;
}

다음은 C #을 사용하는 약간 기능적인 예입니다.

            Func<long>[] backwards = new Func<long>[input.Length];
            Func<long>[] forwards = new Func<long>[input.Length];

            for (int i = 0; i < input.Length; ++i)
            {
                var localIndex = i;
                backwards[i] = () => (localIndex > 0 ? backwards[localIndex - 1]() : 1) * input[localIndex];
                forwards[i] = () => (localIndex < input.Length - 1 ? forwards[localIndex + 1]() : 1) * input[localIndex];
            }

            var output = new long[input.Length];
            for (int i = 0; i < input.Length; ++i)
            {
                if (0 == i)
                {
                    output[i] = forwards[i + 1]();
                }
                else if (input.Length - 1 == i)
                {
                    output[i] = backwards[i - 1]();
                }
                else
                {
                    output[i] = forwards[i + 1]() * backwards[i - 1]();
                }
            }

나는 아니에요 전적으로 이 때문에 생성 된 Funcs의 반 재귀로, O (N) 인 것이 확실하지만, 내 시험을 시사하는 그것의 O (n)의 시간이다.

// 이것은 Java의 재귀 솔루션입니다. // main product (a, 1,0);

public static double product(double[] a, double fwdprod, int index){
    double revprod = 1;
    if (index < a.length){
        revprod = product2(a, fwdprod*a[index], index+1);
        double cur = a[index];
        a[index] = fwdprod * revprod;
        revprod *= cur;
    }
    return revprod;
}

O (n) 런타임의 깔끔한 솔루션 :

1. 각 요소에 대해 그 전에 발생하는 모든 요소의 곱을 계산하고 배열 "pre"에 저장합니다.
2. 각 요소에 대해 해당 요소 다음에 발생하는 모든 요소의 곱을 계산하여 배열 "포스트"에 저장

3. 요소 i에 대한 최종 배열 "결과"를 생성합니다.

   result[i] = pre[i-1]*post[i+1];
   

function solution($array)
{
    $result = [];
    foreach($array as $key => $value){
        $copyOfOriginalArray = $array;
        unset($copyOfOriginalArray[$key]);
        $result[$key] = multiplyAllElemets($copyOfOriginalArray);
    }
    return $result;
}

/**
 * multiplies all elements of array
 * @param $array
 * @return int
 */
function multiplyAllElemets($array){
    $result = 1;
    foreach($array as $element){
        $result *= $element;
    }
    return $result;
}

$array = [1, 9, 2, 7];

print_r(solution($array));

의 문제를 해결하는 또 다른 간단한 개념이 O(N)있습니다.

        int[] arr = new int[] {1, 2, 3, 4, 5};
        int[] outArray = new int[arr.length]; 
        for(int i=0;i<arr.length;i++){
            int res=Arrays.stream(arr).reduce(1, (a, b) -> a * b);
            outArray[i] = res/arr[i];
        }
        System.out.println(Arrays.toString(outArray));

아래에 제공된 O(n)공간 및 O(n^2)시간 복잡성을 가진 솔루션이 있습니다.

public static int[] findEachElementAsProduct1(final int[] arr) {

        int len = arr.length;

//        int[] product = new int[len];
//        Arrays.fill(product, 1);

        int[] product = IntStream.generate(() -> 1).limit(len).toArray();


        for (int i = 0; i < len; i++) {

            for (int j = 0; j < len; j++) {

                if (i == j) {
                    continue;
                }

                product[i] *= arr[j];
            }
        }

        return product;
    }