Bir sayı dizisi verildiğinde, diğer tüm sayıların ürün dizisini döndürün (bölme yok)

Bir iş görüşmesinde bu soruyu sordum ve başkalarının bunu nasıl çözeceğini bilmek istiyorum. Java konusunda en rahatım, ancak diğer dillerdeki çözümlere açıktır.

Bir sayı numsdizisi productsverildiğinde products[i], hepsinin ürünü olan bir sayı dizisi döndürün 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]

Bunu O(N)bölme kullanmadan yapmalısınız .

Poligenel-yağlayıcılar yönteminin açıklaması : Hile, dizileri oluşturmaktır (4 eleman için)

{              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,  }

Her ikisi de sırasıyla sol ve sağ kenarlardan başlayarak O (n) 'de yapılabilir.

Ardından, iki dizi öğesini öğe ile çarpmak, gerekli sonucu verir

Kodum şöyle bir şey olurdu:

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];
}

Uzayda O (1) olmanız gerekiyorsa bunu yapabilirsiniz (daha az net 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];
}

İşte modofication yerinde yapmak için küçük bir özyinelemeli işlev (C ++). Yine de O (n) ekstra alan (yığın üzerinde) gerektirir. Dizinin a ve N dizinin uzunluğu tuttuğunu varsayarsak,

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;
}

İşte bunu Java'da çözme girişimim. Standart olmayan biçimlendirme için özür dileriz, ancak kodun çoğaltılması çok fazladır ve bu, okunabilir hale getirmek için yapabileceğim en iyisidir.

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]"
    }
}

Döngü değişmezleri pi = nums[0] * nums[1] *.. nums[i-1]ve pj = nums[N-1] * nums[N-2] *.. nums[j+1]. Soldaki ikısım "önek" mantığı ve jsağdaki kısım "sonek" mantığıdır.

Özyinelemeli tek astar

Jasmeet (güzel!) Özyinelemeli bir çözüm verdi; Bu (iğrenç!) Java tek astarına çevirdim. It does yerinde modifikasyonu ile, O(N)yığının geçici boşluk.

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'ın çözümünü Haskell'e çevirme:

otherProducts xs = zipWith (*) below above

     where below = scanl (*) 1 $ init xs

           above = tail $ scanr (*) 1 xs

"Bölüm yok" kuralını gizlice atlatmak:

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

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

İşte O (N) karmaşıklığı ile basit ve temiz bir çözüm:

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. Sola Git-> Sağa gidin ve ürünü saklayın. Geçmiş deyin. -> O (n)
2. Sağa Git -> sola ürünü sakla. Gelecek deyin. -> O (n)
3. Sonuç [i] = Geçmiş [i-1] * gelecek [i + 1] -> O (n)
4. Geçmiş [-1] = 1; ve Gelecek [n + 1] = 1;

O (n)

İşte modern C ++ 'daki çözümüm. Kullanır std::transformve hatırlaması oldukça kolaydır.

Çevrimiçi kod (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 << " "; 
}

Bu O (n ^ 2) ama f # çok güzel:

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]

Her bir öğenin solundaki ve sağındaki sayıların çarpımını yeniden hesaplayın. Her element için istenen değer, komşularının ürünlerinin ürünüdür.

#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;
}

Sonuç:

$ ./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

(GÜNCELLEME: şimdi daha yakından bakıyorum, bu Michael Anderson, Daniel Migowski ve yukarıdaki poligeno-yağlayıcılarla aynı yöntemi kullanıyor)

Tricky:

Aşağıdakileri kullanın:

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];
}

Evet, eminim i yerine bazı i-1'i kaçırdım, ama bunu çözmenin yolu bu.

Ayrıca O (N ^ (3/2)) optimal olmayan bir çözelti de vardır. Yine de oldukça ilginç.

İlk olarak, N ^ 0.5 boyutundaki her kısmi çarpımı ön işlemleyin (bu O (N) zaman karmaşıklığında yapılır). Daha sonra, her sayının diğer-değerleri'-katsayısı için hesaplama 2 * O (N ^ 0.5) zamanda yapılabilir (neden? Çünkü sadece diğer ((N ^ 0.5) - 1) sayılarının son öğelerini katlamanız gerekir, ve sonucu, geçerli sayının grubuna ait ((N ^ 0.5) - 1) sayılarla çarpın). Bunu her sayı için yapmak O (N ^ (3/2)) zaman alabilir.

Misal:

4 6 7 2 3 1 9 5 8

kısmi sonuçlar: 4 * 6 * 7 = 168 2 * 3 * 1 = 6 9 * 5 * 8 = 360

3 değerini hesaplamak için, diğer grupların 168 * 360 değerlerini ve ardından 2 * 1 ile çarpılması gerekir.

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);
    }
}

Bu çözümü buldum ve ne düşündüğünü çok net buldum !?

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) baskı prod

Tam olarak burada Scala'daki kod:

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

Bu aşağıdakileri yazdıracaktır:

120
60
40
30
24

Program geçerli öğeyi filtreleyecektir (_! = Elem); ve yeni listeyi reduceLeft yöntemiyle çarpın. Tembel değerlendirme için scala görünümü veya yineleyici kullanırsanız bu O (n) olacağını düşünüyorum.

Billz cevap dayanarak - üzgünüm yorum yapamam, ama burada listede yinelenen öğeleri doğru işleyen ve muhtemelen O (n) bir scala sürümü:

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

İadeler:

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

Javascript çözümümü buraya ekleyerek bunu öneren kimse bulamadım. Başka bir sayıdan bir sayıyı kaç kez çıkarabileceğinizi saymak dışında, bölünecek ne var? Tüm dizinin ürününü hesaplayıp her öğenin üzerinde yineleme yaptım ve geçerli öğeyi sıfıra kadar çıkarıyorum:

//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 # kullanıyorum:

    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;
    }

Önce nums[j](nerede j != i) listesinden hariç tutabiliriz , sonra geri kalanın ürününü alabiliriz; Aşağıdaki python waybu bulmacayı çözmek için:

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]

Bu çözüm C / C ++ çözeltisi olarak düşünülebilir. Diyelim ki bir [n] gibi n eleman içeren bir "a" dizimiz var, sonra sözde kod aşağıdaki gibi olur.

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];
  }

Bir çözüm daha, Bölme kullanarak. iki kez çaprazlama ile. Tüm öğeleri çarpın ve ardından her bir öğeye bölmeye başlayın.

{-
Sqrt (n) alt kümelerini kullanarak özyinelemeli çözüm. O (n) 'de çalışır.

Çözümü, sqrt (n) büyüklüğünde sqrt (n) alt kümelerinde özyinelemeli olarak hesaplar. 
Daha sonra her alt kümenin ürün toplamını geri alır.
Daha sonra her alt kümedeki her bir öğe için ürünü şu hesaplar:
diğer tüm ürünlerin ürün toplamı.
Ardından tüm alt kümeleri düzleştirir.

Çalışma süresinde yineleme T (n) = sqrt (n) * T (sqrt (n)) + T (sqrt (n)) + n

Diyelim ki O (n) 'de 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)

Tavan (sqrt (n)) bir ikili arama kullanılarak hesaplanabileceğini unutmayın 
ve sqrt komutuna izin verilmiyorsa O (logn) yinelemeleri.
-}

otherProducts [] = []
diğerÜrünler [x] = [1]
otherProducts [x, y] = [y, x]
otherProducts a = foldl '(++) [] $ zipWith (\ sp -> harita (* p) s) çözüldü Alt kümeler alt kümesiOtherProducts
    nerede 
      n = uzunluk a

      - Alt küme boyutu. 1 <s <n gerektirir.
      s = Tavan $ sqrt $ fromIntegral n

      solvedSubsets = diğer haritayı eşle
      subsetOtherProducts = otherProducts $ harita ürün alt kümeleri

      subsets = ters $ döngü a []
          burada döngü [] acc = acc
                loop a acc = loop (drop sa) ((sa al): acc)

İşte benim kod:

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;
}

İşte C # kullanarak biraz işlevsel bir örnek:

            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]();
                }
            }

Oluşturulan Func'ların yarı yinelenmesi nedeniyle bunun O (n) olduğundan tam olarak emin değilim , ancak testlerim zamanın O (n) olduğunu gösteriyor gibi görünüyor.

// Bu, Java'daki özyinelemeli çözümdür // Ana üründen (a, 1,0) aşağıdaki gibi adlandırılır;

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) çalışma süresiyle düzgün bir çözüm:

1. Her eleman için ondan önce meydana gelen tüm elemanların çarpımını hesaplayın ve "pre" dizisinde saklayın.
2. Her öğe için, o öğeden sonra gerçekleşen tüm öğelerin ürününü hesaplayın ve bir dizi "post" içinde saklayın

3. İ öğesi için son bir dizi "sonuç" oluşturun,

   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));

İşte sorunu çözen başka bir basit kavram 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));

Aşağıda sağlanan O(n)yer ve O(n^2)zaman karmaşıklığına sahip bir çözümüm var ,

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;
    }