সংখ্যার একটি অ্যারে দেওয়া, অন্যান্য সমস্ত সংখ্যার পণ্যগুলির অ্যারে ফেরত দিন (বিভাগ নেই)

Question

আমাকে এই প্রশ্নটি একটি কাজের সাক্ষাত্কারে জিজ্ঞাসা করা হয়েছিল এবং আমি কীভাবে অন্যরা এটি সমাধান করবে তা জানতে চাই। আমি জাভাতে সবচেয়ে আরামদায়ক, তবে অন্যান্য ভাষায় সমাধানগুলি স্বাগত।

সংখ্যার একটি অ্যারে দেওয়া, একটি সংখ্যার অ্যারে 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)বিভাগটি ব্যবহার না করে আপনাকে এটি করতে হবে ।

Comments

এই প্রশ্নটি গত সপ্তাহে বা আরও কয়েকবার উঠে এসেছে; আপনি সব একই কোম্পানির সাথে সাক্ষাত্কার করছেন? :)

— মাইকেল মরোজেক

আমি বর্তমানে [interview-questions]এটি খুঁজছি ট্যাগ ব্রাউজ করছি । আপনি যদি এটির সন্ধান করেন তবে আপনার কোনও লিঙ্ক আছে?

— বহুবৃক্ষের জন্য

@ মিশেল: এই প্রশ্নটি বিভাগকে অনুমতি দেয়। আমার স্পষ্টভাবে এটি নিষেধ। আমি বলব যে তারা দুটি ভিন্ন প্রশ্ন।

— বহুবিশ্বেষক

লগের সাথে বিকল্প বিভাগ (a / b) = লগ (এ) -লগ (খ) এবং ভয়েলা!

— ldog

ভাবুন যদি অ্যারেতে 1 বা একাধিক জিরো থাকে তবে আপনি কীভাবে মামলা পরিচালনা করবেন ??

— gst

Answer 1

পলিজেনব্রিকেন্টস পদ্ধতির ব্যাখ্যা : কৌশলটি হ'ল অ্যারেগুলি তৈরি করা (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,  }

উভয়ই যথাক্রমে বাম এবং ডান প্রান্ত থেকে শুরু করে ও (এন) এ করা যেতে পারে।

তারপরে দুটি অ্যারে উপাদানকে উপাদান দ্বারা গুণিত করে প্রয়োজনীয় ফলাফল দেয়

আমার কোডটি এরকম কিছু দেখাচ্ছে:

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

আপনার যদি মহাশূন্যে ও (1) হওয়া দরকার তবে আপনি এটি করতে পারেন (যা কম পরিষ্কার আইএমএইচও)

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

Comments

এটি ও (এন) রানটাইম তবে এটি স্থান জটিলতায় ও (এন)। আপনি ও (1) স্পেসে এটি করতে পারেন। আমি বলতে চাইছি, অবশ্যই ইনপুট এবং আউটপুট ধারকগুলির আকার ছাড়া অন্য।

— উইলহেমটেল

খুব চালাক! এই অ্যালগরিদমের কোনও নাম আছে?

— ফাস্টকোডাজভা

@ মাইকেল অ্যান্ডারসন দুর্দান্ত কাজের লোক, তবে দয়া করে আমাকে এর পিছনে মূল যুক্তিটি বলুন এবং আপনি যখন প্রয়োজনীয়তা পেয়েছেন তখন আপনি কীভাবে এটি শুরু করেছিলেন।

— এসিবালাজি

উপাদানগুলির মধ্যে যে কোনও একটি একটি হলে অ্যালগরিদম ব্যর্থ হবে So তাই এড়াতে 0 টি পরীক্ষা করতে ভুলবেন না।

— মণি

@ মানি অ্যালগরিদম ঠিক আছে যদি 0 তে উপাদান থাকে তবে তবে এই জাতীয় উপাদানগুলির জন্য ইনপুট স্ক্যান করা সম্ভব হয় এবং যদি তারা পাওয়া যায় তবে আরও দক্ষ হতে পারে। যদি দুটি শূন্য উপাদান থাকে তবে পুরো ফলাফলটি শূন্য, এবং যদি কেবল একটিই থাকে v_i=0তবে বলুন ফলাফলের মধ্যে একমাত্র অ শূন্য এন্ট্রি হ'ল আইথ উপাদান। তবে আমি সন্দেহ করি যে শূন্য উপাদানগুলি সনাক্ত এবং গণনা করার জন্য একটি পাস যোগ করা সমাধানের স্পষ্টতা থেকে বিরত হতে পারে এবং সম্ভবত বেশিরভাগ ক্ষেত্রেই সত্যিকারের পারফরম্যান্স অর্জন করতে পারে না ..

— মাইকেল অ্যান্ডারসন

Answer 2

মোডোফিকেশন জায়গায় রাখার জন্য এখানে একটি ছোট পুনরাবৃত্ত ফাংশন (সি ++ এ) দেওয়া আছে। যদিও এর জন্য ও (এন) অতিরিক্ত স্থান (স্ট্যাকের) প্রয়োজন। অ্যারেটি ধরে নিচ্ছি এবং 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;
}

Comments

কেউ কি এই পুনরাবৃত্তি ব্যাখ্যা করতে পারে?

— নিখিল

@ নিখিল এটি প্রথমে পুনরাবৃত্তি করে, মধ্যবর্তী পণ্যগুলিকে স্মরণ করে, অবশেষে সংখ্যাটি গঠন করে num[N-1]; তারপরে ফেরার পথে এটি গুণটির দ্বিতীয় অংশ গণনা করে যা পরে সংখ্যার অ্যারেটি সংশোধন করতে ব্যবহৃত হয়।

— জ্যাক

ভাবুন যদি অ্যারেতে 1 বা একাধিক জিরো থাকে তবে আপনি কীভাবে মামলা পরিচালনা করবেন ??

— gst

Answer 3

জাভাতে এটি সমাধান করার জন্য আমার চেষ্টা এখানে। অ-মানক বিন্যাসের জন্য ক্ষমাপ্রার্থী, তবে কোডটির প্রচুর অনুলিপি রয়েছে, এবং এটি পাঠযোগ্যযোগ্য করার জন্য আমি সবচেয়ে সেরা এটি করতে পারি।

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ডান দিকে অংশ "প্রত্যয়" যুক্তি নেই।

---

পুনরাবৃত্ত ওয়ান-লাইনার

জস্মিত একটি (সুন্দর!) পুনরাবৃত্তি সমাধান দিয়েছেন; আমি এটিকে (জঘন্য!) জাভা ওয়ান-লাইনারে পরিণত করেছি। এটি স্ট্যাকের মধ্যে অস্থায়ী স্থান সহ, স্থানটিতে সংশোধন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]"

Comments

আমি মনে করি যে 2-ভেরিয়েবল লুপটি প্রয়োজনের তুলনায় বুঝতে আরও কঠিন করে তোলে (কমপক্ষে আমার দুর্বল মস্তিষ্কের জন্য), দুটি পৃথক লুপও কাজটি করবে।

— গিলাইম

এই কারণেই আমি কোডটি বাম / ডানে বিভক্ত করেছি, এই চেষ্টা করার জন্য যে দু'জন একে অপরের থেকে স্বতন্ত্র। আমি নিশ্চিত না যে এটি আসলে কাজ করে কিনা, যদিও =)

— পলিজেনিউব্রিকেন্টস

Answer 4

মাইকেল অ্যান্ডারসনের সমাধানটি হাস্কেলের মধ্যে অনুবাদ করা:

otherProducts xs = zipWith (*) below above

     where below = scanl (*) 1 $ init xs

           above = tail $ scanr (*) 1 xs

Answer 5

স্নেহকালে "বিভাজনগুলি" বিধি নিষ্ক্রিয় করে:

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

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

Comments

Nitpick: যতদূর আমি সচেতন আছি, কম্পিউটার লগারিদমের তাদের দ্বিপদ সম্প্রসারণ ব্যবহার বাস্তবায়ন - যা আছে বিভাজন প্রয়োজন ...

Answer 6

এখানে আপনি যান (ও) জটিলতার সাথে সহজ এবং পরিষ্কার সমাধান:

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

Answer 7

সি ++, ও (এন):

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

Comments

বিভাগের অনুমতি নেই

— মাইকেল অ্যান্ডারসন

এটি এখনও একটি দুর্দান্ত চেহারা কোড। অস্বীকৃতি দিয়ে যে এটি বিভাগ ব্যবহার করে, তবুও যদি ব্যাখ্যা দেওয়া হয় তবে আমি upvote করব।

— বহুবিশ্বেষক

অভিশাপ, আমি এর মাধ্যমে প্রশ্নটি পড়িনি। : s @ পলিজেলব্রিকেন্টস ব্যাখ্যা: ধারণাটি হল এটি দুটি পদক্ষেপে করা। প্রথমে সংখ্যার প্রথম ক্রমটির ফ্যাক্টরিয়াল নিন। এটিই জমা হওয়া অ্যালগরিদম যা কাজ করে (ডিফল্টরূপে সংখ্যা যোগ করে, তবে সংযোজনটি প্রতিস্থাপন করতে অন্য কোনও বাইনারি অপারেশন নিতে পারে, এক্ষেত্রে একটি গুণ)। এরপরে আমি দ্বিতীয়বার ইনপুট সিকোয়েন্সটি দিয়ে পুনরাবৃত্তি করলাম, এটিকে রূপান্তরিত করে আউটপুট অনুক্রমের সাথে সম্পর্কিত উপাদানটি পূর্ববর্তী ধাপে ইনপুট অনুক্রমের সাথে সংশ্লিষ্ট উপাদান দ্বারা বিভক্ত বিবরণী আমি গণনা করেছি।

— উইলহেমটেল

"প্রথম অনুক্রমের ফ্যাকটোরিয়াল"? Wtf? আমি ক্রম উপাদানগুলির অর্থ।

— উইলহেমটেল

Answer 8

1. বাম ভ্রমণ -> ডান এবং পণ্য সংরক্ষণ চালিয়ে যান। একে অতীত বলুন। -> ও (এন)
2. ভ্রমণ ডান -> বাম পণ্য রাখুন। একে ফিউচার বলে। -> ও (এন)
3. ফলাফল [i] = অতীত [i-1] * ভবিষ্যত [i + 1] -> ও (এন)
4. অতীত [-1] = 1; এবং ভবিষ্যত [n + 1] = 1;

চালু)

Answer 9

আধুনিক সি ++ তে আমার সমাধান এখানে। এটি ব্যবহার করে std::transformএবং এটি মনে রাখা বেশ সহজ।

অনলাইন কোড (ভ্যান্ডবক্স)।

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

Answer 10

এটি ও (এন ^ 2) তবে এফ # খুব সুন্দর:

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]

Comments

আমি নিশ্চিত নই যে ওয়ান (এন) সমস্যার সমাধানের জন্য প্রচুর ওয়ান লাইনার বা ও (এন ^ 2) সর্বদা "সুন্দর"।

— ম্যাড পদার্থবিদ

Answer 11

বামে এবং প্রতিটি উপাদানের ডানদিকে সংখ্যার গুণফলকে প্রাক্কুলেট করুন। প্রতিটি উপাদানের জন্য কাঙ্ক্ষিত মান হল এটি তার নেগ্রোসের পণ্য।

#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

(আপডেট: এখন আমি আরও ঘনিষ্ঠভাবে দেখি, এটি মাইকেল অ্যান্ডারসন, ড্যানিয়েল মিগোভস্কি এবং উপরের পলিলেগ্লুব্রিকেন্টগুলির মতো একই পদ্ধতি ব্যবহার করে)

Comments

এই অ্যালগরিদমের নাম কী?

— onepiece

Answer 12

কৌশলী:

নিম্নলিখিত ব্যবহার:

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

হ্যাঁ, আমি নিশ্চিত যে আমি আমার পরিবর্তে কিছু আই -1 মিস করেছি তবে এটি সমাধানের উপায়টি ts

Answer 13

এছাড়াও একটি ও (এন ^ (3/2)) অপ -অনুকূল সমাধান রয়েছে। যদিও এটি বেশ আকর্ষণীয়।

প্রথমে আকার N ^ 0.5 এর আংশিক গুণগুলি প্রিপ্রোসেস করুন (এটি ও (এন) সময় জটিলতায় করা হয়)। তারপরে, প্রতিটি সংখ্যার অন্যান্য-মান'-একাধিকের জন্য গণনা 2 * O (N ^ 0.5) সময়ে করা যেতে পারে (কেন? কারণ আপনাকে কেবলমাত্র অন্যান্য ((N ^ 0.5) - 1) সংখ্যার শেষ উপাদানগুলি একাধিক করতে হবে, এবং ফলাফলটি ((N ^ 0.5) - 1) বর্তমান সংখ্যার গ্রুপের অন্তর্ভুক্ত সংখ্যার সাথে গুণিত করুন)। প্রতিটি সংখ্যার জন্য এটি করা, কেউ ও (এন ^ (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 দিয়ে গুণ করা দরকার।

Answer 14

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

এই সমাধানটি আমি নিয়ে এসেছি এবং এটি আপনার কাছে কী মনে হয় তা এতটাই পরিষ্কার পেয়েছি !?

Comments

আপনার সমাধানে O (n ^ 2) সময়ের জটিলতা উপস্থিত রয়েছে।

— ম্যাড পদার্থবিজ্ঞানী

Answer 15

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

আরআর = [1, 2, 3, 4, 5] প্রোড = [] প্রডাক্টাইফাই (আরআর, প্রোড, 0) প্রিন্ট প্রোড

Answer 16

এখানে সম্পূর্ণ হওয়ার জন্য স্কালায় কোডটি রয়েছে:

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

এটি নিম্নলিখিত মুদ্রণ করবে:

120
60
40
30
24

প্রোগ্রামটি বর্তমান এলেমকে ফিল্টার করবে (_! = এলেম); এবং কমান্ড লেফট পদ্ধতিতে নতুন তালিকাটিকে গুণিত করুন। আমার মনে হয় আপনি অলসতার জন্য স্ক্যাল ভিউ বা আইট্রেটার ব্যবহার করলে এটি ও (এন) হবে।

Comments

সত্ত্বেও খুব মার্জিত, যদি সেখানে একই মান সঙ্গে আরো উপাদান এটা কাজ করে না: Val তালিকা 1 = তালিকা (1, 7, 3, 3, 4, 4)

— জিওর্দানো Scalzo

আমি কোডটি পুনরাবৃত্তি করে আবার পরীক্ষা করেছি tested এটি নিম্নলিখিত 1008 144 112 112 63 63 উত্পাদন করে আমি মনে করি যে প্রদত্ত উপাদানটির জন্য এটি সঠিক।

— বিলজ

Answer 17

বিলজ উত্তরের উপর ভিত্তি করে - দুঃখিত আমি মন্তব্য করতে পারছি না, তবে এখানে একটি স্কালা সংস্করণ যা তালিকার সদৃশ আইটেমগুলিকে সঠিকভাবে পরিচালনা করে এবং সম্ভবত ও (এন):

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)

Answer 18

আমার জাভাস্ক্রিপ্ট সমাধানটি এখানে যুক্ত করা হচ্ছে কারণ আমি এটির পরামর্শ দেওয়ার মতো কাউকে পাইনি। বিভাজন কী, আপনি অন্য নম্বর থেকে একটি সংখ্যা বের করতে পারেন এমন সময় গণনা ব্যতীত কী? আমি পুরো অ্যারের পণ্য গণনা করেছিলাম এবং তারপরে প্রতিটি উপাদানকে নিয়ে পুনরাবৃত্তি করেছি এবং বর্তমান উপাদানটি শূন্য পর্যন্ত বাদ দিয়েছি:

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

Answer 19

আমি সি # তে ব্যবহার করছি:

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

Answer 20

আমরা প্রথমে তালিকাটি nums[j](যেখানে 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]

Answer 21

ঠিক আছে, এই সমাধানটি সি / সি ++ এর হিসাবে বিবেচনা করা যেতে পারে। ধরুন আমাদের একটি অ্যারে আছে "a" এর মতো এন উপাদানগুলি রয়েছে [n], তবে সিউডো কোডটি নীচের মত হবে।

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

Answer 22

আরও একটি সমাধান, বিভাগ ব্যবহার করে। দুবার ট্র্যাভারসাল সহ। সমস্ত উপাদানকে গুণিত করুন এবং তারপরে প্রতিটি উপাদান দ্বারা এটি ভাগ করা শুরু করুন।

Answer 23

{-
স্কয়ার্ট (এন) সাবসেট ব্যবহার করে পুনরাবৃত্ত সমাধান। ও (এন) এ চলে।

আকার sqrt (n) এর উপসেটগুলিতে পুনরাবৃত্তভাবে সমাধানটি গণনা করে। 
তারপরে প্রতিটি উপসেটের পণ্য যোগফলের পুনরাবৃত্তি হয়।
তারপরে প্রতিটি উপসেটের প্রতিটি উপাদানগুলির জন্য, এটি পণ্যটির সাথে সংখ্যায়ন করে
অন্যান্য সমস্ত পণ্যের যোগফল।
তারপরে সমস্ত সাবসেট সমতল করুন

রান টাইমে পুনরাবৃত্তিটি হ'ল টি (এন) = স্কয়ার্ট (এন) * টি (স্ক্রুট (এন)) + টি (স্কয়ার্ট (এন)) + এন

মনে করুন যে ও (এন) তে টি (এন) n সিএন

টি (এন) = স্কয়ার্ট (এন) * টি (স্কয়ার্ট (এন)) + টি (স্কয়ার্ট (এন)) + এন
    ≤ sqrt (n) * c * sqrt (n) + c * sqrt (n) + n
    ≤ সি * এন + সি * স্ক্রুট (এন) + এন
    ≤ (2 সি + 1) * এন
    ∈ ও (এন)

নোট করুন যে সিলিং (স্কয়ার্ট (এন)) বাইনারি অনুসন্ধান ব্যবহার করে গণনা করা যেতে পারে 
এবং O (লগন) পুনরাবৃত্তি, যদি স্কয়ার্ট নির্দেশের অনুমতি না থাকে।
-}

অন্যান্য পণ্যগুলি [] = []
অন্যান্য উত্পাদন [এক্স] = [1]
অন্যান্য পণ্যগুলি [x, y] = [y, x]
otherProdates a = ভাঁজ '(++) [] ip জিপউইথ (\ এসপি -> মানচিত্র (* পি) গুলি) সমাধান করা সাবসেটস সাবসেটঅথারপ্রডাক্ট
    কোথায় 
      n = দৈর্ঘ্য a

      - সাবসেট আকার। প্রয়োজনীয় যে 1 <এস <এন।
      s = সিলিং $ sqrt $ fromIntegral n

      সলিউডসুবসেটস = অন্যান্য মানচিত্রের উপসেটগুলি তৈরি করুন
      সাবসেটঅথারপ্রডাক্টস = অন্যান্যপ্রডাক্টস $ মানচিত্রের উপগ্রহগুলি

      উপসেটস = বিপরীত $ লুপ এ []
          যেখানে লুপ [] acc = acc
                লুপ একটি এ্যাক = লুপ (ড্রপ সা) ((সা) নিন)

Answer 24

আমার কোডটি এখানে:

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

Answer 25

সি # ব্যবহার করে এখানে কিছুটা কার্যকরী উদাহরণ রয়েছে:

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

আমি পুরোপুরি নিশ্চিত নই যে এটি তৈরি করা ফানকসের আধা পুনরাবৃত্তির কারণে এটি ও (এন), তবে আমার পরীক্ষাগুলি মনে হয় যে এটি সময় মতো ও (এন)।

Answer 26

// এটি জাভাতে পুনরাবৃত্তির সমাধান // মূল পণ্য (ক, 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;
}

Answer 27

ও (এন) রানটাইম সহ একটি ঝরঝরে সমাধান:

1. প্রতিটি উপাদানের জন্য তার আগে উপস্থিত সমস্ত উপাদানগুলির পণ্য গণনা করুন এবং এটি একটি অ্যারে "প্রাক" এ সঞ্চয় করে।
2. প্রতিটি উপাদানের জন্য সেই উপাদানটির পরে উপস্থিত সমস্ত উপাদানগুলির পণ্য গণনা করুন এবং এটি একটি অ্যারে "পোস্ট" এ সঞ্চয় করুন

3. আমি একটি এলিমেন্টের জন্য একটি চূড়ান্ত অ্যারে "ফলাফল" তৈরি করুন,

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

Comments

এটি কি গ্রহণযোগ্য হিসাবে একই সমাধান, তাই না?

— টমাস আহলে

Answer 28

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

Answer 29

এখানে আরও একটি সহজ ধারণা যা সমস্যার সমাধান করে 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));

Answer 30

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