# 🚀 2626 — Array Reduce Transformation


## 🔹 Array.prototype.reduce() কী?

reduce() হল জাভাস্ক্রিপ্টের একটি বিল্ট-ইন মেথড যেটা একটি অ্যারেকে একক ভ্যালুতে (সংখ্যা, অবজেক্ট, স্ট্রিং ইত্যাদি) “রিডিউস” করে।

এটি প্রতিটি উপাদানের ওপর আপনার দেওয়া একটি রিডিউসার ফাংশন চালায়।
প্রতিটি ধাপে একটি accumulator (সঞ্চিত মান) থাকে যেটি আপডেট হয়।

### 🔹 সিনট্যাক্স
```js
arr.reduce((accumulator, currentValue, index, array) => {
  // এখানে আপডেটেড accumulator রিটার্ন করতে হবে
}, initialValue);
```
- accumulator → আগের ধাপের ফলাফল (বা প্রথমে initialValue)
- currentValue → অ্যারের বর্তমান উপাদান
- index → ঐ উপাদানের ইন্ডেক্স (ঐচ্ছিক)
- array → মূল অ্যারে (ঐচ্ছিক)
- initialValue → accumulator-এর শুরুর মান

### 🔹 কেন ব্যবহার করা হয়
- সংখ্যাগুলোর যোগফল বা গুণফল বের করা
- অবজেক্ট বা ম্যাপ বানানো (যেমন ফ্রিকোয়েন্সি কাউন্ট)
- nested অ্যারে ফ্ল্যাট করা
- একই পাসে filter+map করা
- ডেটা ট্রান্সফরমেশন

### 🔹 উদাহরণ ১ – সংখ্যার যোগফল
```js
const numbers = [10, 20, 30, 40];
const sum = numbers.reduce((acc, n) => acc + n, 0);
console.log(sum); // 100

```
### 🔹 উদাহরণ ২ – নেস্টেড অ্যারে ফ্ল্যাট করা
```js
const nested = [[1,2],[3,4],[5]];
const flat = nested.reduce((acc, arr) => acc.concat(arr), []);
console.log(flat); // [1,2,3,4,5]
```

### 🔹 উদাহরণ ৩ – ফ্রিকোয়েন্সি ম্যাপ বানানো
```js
const pets = ['cat','dog','cat','fish','dog'];
const freq = pets.reduce((acc, pet) => {
  acc[pet] = (acc[pet] || 0) + 1;
  return acc;
}, {});
console.log(freq); // { cat: 2, dog: 2, fish: 1 }
```

## Problem Statement  

আমাদের একটি `reduce` ফাংশন তৈরি করতে হবে, যেটি একটি অ্যারে `arr`, একটি reducer function `fn` এবং একটি `initialValue` নেবে।  
এই ফাংশনটি প্রতিটি ধাপে `fn(accumulator, currentValue, index)` চালিয়ে একটি একক আউটপুট ভ্যালু রিটার্ন করবে।

---

## Approaches  

### 🔹 1. Using a `for` loop (classic way)

```javascript
var reduce = function (arr, fn, initialValue) {
  let acc = initialValue;
  for (let i = 0; i < arr.length; i++) {
    acc = fn(acc, arr[i], i);
  }
  return acc;
};
```

### 🔹 2. Using for...of with index

```js
var reduce = function (arr, fn, initialValue) {
  let acc = initialValue;
  for (let [i, val] of arr.entries()) {
    acc = fn(acc, val, i);
  }
  return acc;
};
```
### 🔹 3. Using forEach
```js
var reduce = function (arr, fn, initialValue) {
  let acc = initialValue;
  arr.forEach((val, i) => {
    acc = fn(acc, val, i);
  });
  return acc;
};
```
### 🔹 4. Using recursion
```js
var reduce = function (arr, fn, initialValue, i = 0) {
  if (i >= arr.length) return initialValue;
  const nextAcc = fn(initialValue, arr[i], i);
  return reduce(arr, fn, nextAcc, i + 1);
};
```
### Example Usage
```js
// sum of numbers
console.log(
  reduce([1, 2, 3, 4], (acc, n) => acc + n, 0)
);  
// 10

// concatenate strings
console.log(
  reduce(['a','b','c'], (acc, ch) => acc + ch, '')
);  
// "abc"

// flatten nested array
console.log(
  reduce([[1,2],[3,4],[5]], (acc, arr) => acc.concat(arr), [])
);  
// [1,2,3,4,5]
```
✅ All these implementations produce the same result.


## Key Takeaways
* reduce দিয়ে যেকোনো ধরনের অ্যাগ্রিগেশন, ট্রান্সফরমেশন, বা নতুন স্ট্রাকচার তৈরি করা যায়।
* Classic loops, higher-order functions এবং recursion সবক’টিই একই ফলাফল দিতে পারে।
* এই প্যাটার্নগুলো শিখলে functional programming ও array manipulation এ দক্ষতা বাড়ে।