লিনকিউ সমষ্টিগত অ্যালগরিদম ব্যাখ্যা করা হয়েছে

721

এটি লম্পট শব্দ হতে পারে, কিন্তু আমি এর সত্যিই ভাল ব্যাখ্যা খুঁজে পাইনি Aggregate।

ভাল মানে সংক্ষিপ্ত, বর্ণনামূলক, একটি ছোট এবং স্পষ্ট উদাহরণ সহ ব্যাপক।

c#  .net  linq  aggregate 
— আলেকজান্ডার ব্লেটস্কি
সূত্র

উত্তর:

1015

সবচেয়ে সহজ-অনুধাবন করার সংজ্ঞাটি Aggregateহ'ল এটি আগে যে কাজগুলি করেছে তা বিবেচনায় রেখে তালিকার প্রতিটি উপাদানটিতে একটি অপারেশন করে। এর অর্থ এটি প্রথম এবং দ্বিতীয় উপাদানটির ক্রিয়া সম্পাদন করে এবং ফলাফলটি এগিয়ে নিয়ে যায়। তারপরে এটি পূর্ববর্তী ফলাফল এবং তৃতীয় উপাদানটির উপর পরিচালনা করে এবং এগিয়ে চলে। প্রভৃতি

উদাহরণ 1. সংখ্যার যোগফল

var nums = new[]{1,2,3,4};
var sum = nums.Aggregate( (a,b) => a + b);
Console.WriteLine(sum); // output: 10 (1+2+3+4)

এটি যোগ 1এবং 2করা 3। তারপরে যোগ করতে 3(পূর্ববর্তী ফলাফল) এবং 3(ক্রমের পরবর্তী উপাদান) তৈরি করতে হবে 6। তারপরে যোগ 6এবং 4করা 10।

উদাহরণ 2. স্ট্রিংগুলির একটি অ্যারে থেকে একটি সিএসভি তৈরি করুন

var chars = new []{"a","b","c", "d"};
var csv = chars.Aggregate( (a,b) => a + ',' + b);
Console.WriteLine(csv); // Output a,b,c,d

এটি অনেকটা একইভাবে কাজ করে। aএকটি কমা সংবিধান এবং bকরা a,b। তারপরে a,b কমা দিয়ে এবং cতৈরি করতে সম্মতি জানায় a,b,c। ইত্যাদি।

উদাহরণ ৩. বীজ ব্যবহার করে সংখ্যাগুলি গুণমান

সম্পূর্ণতার জন্য, একটি ওভারলোড রয়েছে Aggregateযার একটি বীজ মান নেয়।

var multipliers = new []{10,20,30,40};
var multiplied = multipliers.Aggregate(5, (a,b) => a * b);
Console.WriteLine(multiplied); //Output 1200000 ((((5*10)*20)*30)*40)

উপরোক্ত উদাহরণগুলির মত অনেকগুলি, এটি একটি মান দিয়ে শুরু হয় 5এবং ক্রমটির প্রথম উপাদান দ্বারা এটির 10ফলাফল দিয়ে গুণ করে 50। এই ফলাফলটি এগিয়ে চালিত করা হয় এবং 20ফলাফল প্রদানের ক্রমের পরবর্তী সংখ্যা দ্বারা গুণিত হয় 1000। এটি ক্রমের বাকি 2 টি উপাদানটির মাধ্যমে অব্যাহত থাকে।

লাইভ উদাহরণ: http://rextester.com/ZXZ64749
ডক্স: http://msdn.microsoft.com/en-us/library/bb548651.aspx

অভিযোজ্য বস্তু

উদাহরণস্বরূপ 2, কমা দ্বারা পৃথক করা মানগুলির তালিকা তৈরি করতে স্ট্রিং সংযোগ ব্যবহার করে ation এটি Aggregateএই উত্তরটির উদ্দেশ্য ছিল এর ব্যবহারটি ব্যাখ্যা করার একটি সরল উপায় istic যাইহোক, তথ্য আসলে কমা একটি বৃহৎ পরিমাণ তৈরি করতে এই কৌশল ব্যবহার করে পৃথক, এটা আরো উপযুক্ত একটি ব্যবহার করতে হবে StringBuilder, এবং এই সঙ্গে সম্পূর্ণরূপে সুসংগত Aggregateশুরু করার বাছাই জমিদার ব্যবহার StringBuilder।

var chars = new []{"a","b","c", "d"};
var csv = chars.Aggregate(new StringBuilder(), (a,b) => {
    if(a.Length>0)
        a.Append(",");
    a.Append(b);
    return a;
});
Console.WriteLine(csv);

আপডেট হওয়া উদাহরণ: http://rextester.com/YZCVXV6464

— Jamiec
সূত্র
11
প্রথম বর্ণনার জন্য আরেকটি ব্যাখ্যা হ'ল আপনি যে ফাংশনটি সরবরাহ করেন তা সর্বদা প্রথম দুটি সদস্যকে একত্রিত করে অবধি একটি উপাদানকে সঙ্কুচিত না করা হয়। সুতরাং এবং পরে [1,2,3,4]হবে । তবে একটি একক মানের অ্যারে ফিরার পরিবর্তে আপনি কেবল মানটি পান। [3,3,4][6,4][10]
— ডেভিড র্যাব
2
আমি কি কোনও প্রাথমিক কার্য থেকে তাড়াতাড়ি ব্রেক / প্রস্থান করতে পারি? উদাহরণস্বরূপ, chars.Agregregate ((a, b) => {যদি (a == 'a') পুরো সমষ্টি ভেঙে অন্য একটি + ',' + বি}) ফেরায়
— জেফ টিয়ান
13
@ জেফটিয়ান - আমি TakeWhileতখন একটি শৃঙ্খলাবদ্ধ করার পরামর্শ দিচ্ছি Aggregate- গণ্য এক্সটেনশনের মারধর - তারা সহজে শৃঙ্খলাবদ্ধ। সুতরাং আপনি শেষ TakeWhile(a => a == 'a').Aggregate(....)। এই উদাহরণটি দেখুন: rextester.com/WPRA60543
— জামিয়েক
2
সংযোজনের উপর একটি সিডনোট হিসাবে, পুরো ব্লকটি সহজেই প্রতিস্থাপন করা যায় var csv = string.Join(",", chars)(সমষ্টি বা স্ট্রিংবিল্ডারের কোনও প্রয়োজন নেই) - তবে হ্যাঁ, আমি জানি যে উত্তরটির বিন্দুটি ছিল সামগ্রিকের উদাহরণ ব্যবহার করা যাতে এটি দুর্দান্ত। তবে আমি এখনও উল্লেখ করতে চেয়েছিলাম যে এটি কেবল স্ট্রিংগুলিতে যোগদানের জন্য প্রস্তাবিত নয়, ইতিমধ্যে এর জন্য উত্সর্গীকৃত একটি পদ্ধতি রয়েছে ....
— T_D
2
অন্য একটি সাধারণ ব্যবহার (এখন পর্যন্ত কেবলমাত্র আমি প্রডাকশন var biggestAccount = Accounts.Aggregate((a1, a2) => a1.Amount >= a2.Amount ? a1 : a2);
— ফ্রাঙ্ক
133

আপনি কোন ওভারলোডের কথা বলছেন তার উপর এটি আংশিকভাবে নির্ভর করে তবে মূল ধারণাটি হ'ল:

  • "বর্তমান মান" হিসাবে একটি বীজ দিয়ে শুরু করুন
  • ক্রম উপর আইট্রেট। ক্রমের প্রতিটি মানের জন্য:
    • রুপান্তর ব্যবহারকারী-নির্দিষ্ট ফাংশন প্রয়োগ (currentValue, sequenceValue)মধ্যে(nextValue)
    • সেট currentValue = nextValue
  • ফাইনাল ফিরিয়ে দিন currentValue

আপনি Aggregateআমার এডুলিনক সিরিজের পোস্টটি দরকারী দেখতে পেতে পারেন - এতে আরও বিশদ বিবরণ (বিভিন্ন ওভারলোড সহ) এবং বাস্তবায়ন অন্তর্ভুক্ত রয়েছে।

একটি সহজ উদাহরণ Aggregateবিকল্প হিসাবে ব্যবহার করা হয় Count:

// 0 is the seed, and for each item, we effectively increment the current value.
// In this case we can ignore "item" itself.
int count = sequence.Aggregate(0, (current, item) => current + 1);

অথবা সম্ভবত স্ট্রিংগুলির ক্রমগুলির মধ্যে সমস্ত দৈর্ঘ্যের সংমিশ্রণ:

int total = sequence.Aggregate(0, (current, item) => current + item.Length);

ব্যক্তিগতভাবে আমি খুব কমই খুঁজে Aggregateদরকারী - "উপযোগী" অ্যাগ্রিগেশন পদ্ধতি আমার জন্য সাধারণত ভাল যথেষ্ট।

— জন স্কিটি
সূত্র
6
@ জোন এমন কি কি সমষ্টিগতের অবিচ্ছিন্ন প্রকরণ রয়েছে যা আইটেমগুলিকে একটি গাছে ভাগ করে দেয় যাতে কাজগুলি কোরগুলির মধ্যে বিভক্ত হয়? দেখে মনে হচ্ছে পদ্ধতির নকশাটি "হ্রাস" বা "ভাঁজ" এর ধারণার সাথে সামঞ্জস্যপূর্ণ, তবে আমি জানি না যে এটি হুডের নিচে সত্যিই এটি করছে কিনা, বা কেবলমাত্র আইটেমের তালিকার মাধ্যমে পুনরাবৃত্তি করছে।
— অ্যারোনএলএস
@ জন: উপরে উল্লিখিত এডুলিংক কাজ করছে না আপনি আমাকে ডান সংযোগে পুনর্নির্দেশ করতে পারেন। এবং আপনি দয়া করে আপনার উত্তরে ব্যবহৃত "সংযুক্ত" সমষ্টি ফাংশন সম্পর্কে আরও নির্দিষ্ট হতে পারেন।
— কুশিক
1
@ কুশিক: আমি পোস্টটিতে লিঙ্কটি ঠিক করেছি। "উপস্থাপিত" সমষ্টি ফাংশন দ্বারা আমি সর্বোচ্চ / মিনিট / গণনা / যোগফলের মতো জিনিস বোঝাতে চাইছি।
— জন স্কিটি
62

সুপার শর্ট এগ্রিগ্রেট হাস্কেল / এমএল / এফ # তে ভাঁজের মতো কাজ করে।

সামান্য দীর্ঘ। ম্যাক্স (), .মিন (), সুম (),। গড় () সবগুলি ক্রমিক উপাদানগুলির উপর পুনরাবৃত্তি করে এবং সম্পর্কিত সমষ্টিগত ফাংশনটি ব্যবহার করে এগুলিকে একত্রিত করে। .গ্রাগেট ()টিকে সাধারণীকরণকৃত সমষ্টি হয় যাতে এটি বিকাশকারীকে স্টার্ট স্টেট (ওরফে বীজ) এবং সমষ্টিগত ফাংশন নির্দিষ্ট করতে দেয়।

আমি জানি আপনি একটি সংক্ষিপ্ত ব্যাখ্যা চেয়েছিলেন তবে আমি বুঝতে পেরেছিলাম যে অন্যরা দু'টি সংক্ষিপ্ত উত্তর দিয়েছিল আমি ভেবেছিলাম আপনি সম্ভবত কিছুটা দীর্ঘতর বিষয়ে আগ্রহী হবেন

কোড সহ লম্বা সংস্করণ কীভাবে তা বোঝায় তার উপায় আপনি কীভাবে একবার নমুনা স্ট্যান্ডার্ড বিচ্যুতিটি একবার প্রয়োগ করেছিলেন এবং একবার ব্যবহার করেছিলেন তা দেখানো হতে পারে wayগ্রিগেট। দ্রষ্টব্য: আমি এখানে পারফরম্যান্সকে অগ্রাধিকার দিইনি তাই আমি অযৌক্তিকভাবে সংগ্রহের উপরে কয়েকবার পুনরাবৃত্তি করি

চতুর্ভুজ দূরত্বের যোগফল তৈরি করতে প্রথমে ব্যবহৃত একটি সহায়ক ফাংশন:

static double SumOfQuadraticDistance (double average, int value, double state)
{
    var diff = (value - average);
    return state + diff * diff;
}

তারপরে ForEach ব্যবহার করে নমুনা স্ট্যান্ডার্ড বিচ্যুতি:

static double SampleStandardDeviation_ForEach (
    this IEnumerable<int> ints)
{
    var length = ints.Count ();
    if (length < 2)
    {
        return 0.0;
    }

    const double seed = 0.0;
    var average = ints.Average ();

    var state = seed;
    foreach (var value in ints)
    {
        state = SumOfQuadraticDistance (average, value, state);
    }
    var sumOfQuadraticDistance = state;

    return Math.Sqrt (sumOfQuadraticDistance / (length - 1));
}

তারপরে একবার .আগ্রিগেট ব্যবহার করুন:

static double SampleStandardDeviation_Aggregate (
    this IEnumerable<int> ints)
{
    var length = ints.Count ();
    if (length < 2)
    {
        return 0.0;
    }

    const double seed = 0.0;
    var average = ints.Average ();

    var sumOfQuadraticDistance = ints
        .Aggregate (
            seed,
            (state, value) => SumOfQuadraticDistance (average, value, state)
            );

    return Math.Sqrt (sumOfQuadraticDistance / (length - 1));
}

দ্রষ্টব্য যে এই ফাংশনগুলি SumOfQuadratic দূরত্ব গণনা করা ব্যতীত অভিন্ন:

var state = seed;
foreach (var value in ints)
{
    state = SumOfQuadraticDistance (average, value, state);
}
var sumOfQuadraticDistance = state;

বনাম:

var sumOfQuadraticDistance = ints
    .Aggregate (
        seed,
        (state, value) => SumOfQuadraticDistance (average, value, state)
        );

সুতরাং .আগ্রিগেটটি যা করে তা হ'ল এটি এই একাগ্রেটার প্যাটার্নটিকে আবদ্ধ করে এবং আমি প্রত্যাশা করি .গ্রিগেটের প্রয়োগটি এরকম কিছু দেখবে:

public static TAggregate Aggregate<TAggregate, TValue> (
    this IEnumerable<TValue> values,
    TAggregate seed,
    Func<TAggregate, TValue, TAggregate> aggregator
    )
{
    var state = seed;

    foreach (var value in values)
    {
        state = aggregator (state, value);
    }

    return state;
}

স্ট্যান্ডার্ড বিচ্যুতি ফাংশন ব্যবহার করে এরকম কিছু দেখতে পাওয়া যাবে:

var ints = new[] {3, 1, 4, 1, 5, 9, 2, 6, 5, 4};
var average = ints.Average ();
var sampleStandardDeviation = ints.SampleStandardDeviation_Aggregate ();
var sampleStandardDeviation2 = ints.SampleStandardDeviation_ForEach ();

Console.WriteLine (average);
Console.WriteLine (sampleStandardDeviation);
Console.WriteLine (sampleStandardDeviation2);

এই প্রোগ্রামটিতে

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

— ঠিক আর একটি রূপক
সূত্র
+1 দুর্দান্ত! তবে এক্সটেনশন পদ্ধতিগুলি SampleStandardDeviation_Aggregate()এবং (অ্যাক্সেস যোগ্যতা অর্জনের অভাবে ডিফল্টরূপে) SampleStandardDeviation_ForEach()হতে পারে না private, সুতরাং এটি উভয়ই দ্বারা অর্জন করা উচিত ছিল publicবা internalএটি আমার কাছে মনে হয়
— ফুলপ্রুফ
এফওয়াইআই: যদি আমি সঠিকভাবে মনে করি তবে আমার নমুনায় সম্প্রসারণের পদ্ধতিগুলি একই শ্রেণীর অংশ ছিল যা তাদেরকে এই ক্ষেত্রে ব্যক্তিগত কাজগুলি ব্যবহার করেছিল ==>
— ঠিক অন্য একটি রূপক
39

একটি ছবি হাজার শব্দের সমান

অনুস্মারক:
Func<X, Y, R>টাইপ দুটি ইনপুট সহ একটি ফাংশন Xএবং Y, যা টাইপের ফলাফল প্রদান করে R।

গণনাযোগ্য.এগ্রিগ্রেটে তিনটি ওভারলোড রয়েছে:


ওভারলোড 1:

A Aggregate<A>(IEnumerable<A> a, Func<A, A, A> f)

Aggregate1

উদাহরণ:

new[]{1,2,3,4}.Aggregate((x, y) => x + y);  // 10


এই ওভারলোডটি সহজ, তবে এর নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

  • ক্রমটিতে কমপক্ষে একটি উপাদান থাকা উচিত,
    অন্যথায় ফাংশনটি একটি নিক্ষেপ করবে InvalidOperationException।
  • উপাদান এবং ফলাফল একই ধরণের হতে হবে।


ওভারলোড 2:

B Aggregate<A, B>(IEnumerable<A> a, B bIn, Func<B, A, B> f)

Aggregate2

উদাহরণ:

var hayStack = new[] {"straw", "needle", "straw", "straw", "needle"};
var nNeedles = hayStack.Aggregate(0, (n, e) => e == "needle" ? n+1 : n);  // 2


এই ওভারলোডটি আরও সাধারণ:

  • একটি বীজ মান সরবরাহ করা আবশ্যক ( bIn)।
  • সংগ্রহটি খালি থাকতে পারে
    , এক্ষেত্রে ফাংশনটি ফলস্বরূপ বীজের মান অর্জন করবে।
  • উপাদান এবং ফলাফল বিভিন্ন ধরণের হতে পারে।


ওভারলোড 3:

C Aggregate<A,B,C>(IEnumerable<A> a, B bIn, Func<B,A,B> f, Func<B,C> f2)


তৃতীয় ওভারলোড খুব কার্যকর আইএমও নয়।
ওভারলোড 2 ব্যবহার করে এটির ফলস্বরূপে রূপান্তরিত করে এমন একটি ফাংশন অনুসরণ করে একইভাবে আরও সাবলীলভাবে লেখা যেতে পারে।


চিত্রগুলি এই দুর্দান্ত ব্লগপোস্ট থেকে অভিযোজিত ।

— 3dGrabber
সূত্র
এটি হাসেল সম্পর্কে একটি প্রশ্নে .... একটি দুর্দান্ত উত্তর হবে। কিন্তু Aggegate। নেট এর কোনও ওভারলোড নেই যা গ্রহণ করে Func<T, T, T>।
— জমিয়েক
4
হ্যাঁ আছে । আপনি আপনার নিজের উত্তরে এটি ব্যবহার করুন!
— ডিগ্রাবার
1
উপস্থাপনা করা কারণ আপনি ক্রমটি খালি থাকলে কী ঘটে তা সাবধানতার সাথে বর্ণনা করে। যাক এন সোর্সে উপাদানের সংখ্যা হতে হবে। আমরা লক্ষ্য করেছি যে ওভারলোড যে গ্রহণ করে না seed, সেগুলি জেনারেটর ফাংশন N -1 বার প্রয়োগ করে ; যখন অন্যান্য overloads (যে কি নিতে একটি seed) সঁচায়ক ফাংশন প্রয়োগ এন বার।
— জেপ্প স্টিগ নীলসেন
17

সমষ্টিগতভাবে মূলত ডেটা গ্রুপ বা সংযুক্ত করতে ব্যবহৃত হয়।

এমএসডিএন অনুসারে "সমষ্টিগত ফাংশন একটি অনুক্রমের উপর একটি সঞ্চয়ের ফাংশন প্রয়োগ করে।"

উদাহরণ 1: একটি অ্যারেতে সমস্ত সংখ্যা যুক্ত করুন।

int[] numbers = new int[] { 1,2,3,4,5 };
int aggregatedValue = numbers.Aggregate((total, nextValue) => total + nextValue);

* গুরুত্বপূর্ণ: ডিফল্ট হিসাবে প্রাথমিক সমষ্টিগত মান হ'ল সংগ্রহের ক্রমের 1 উপাদান element অর্থাৎ: মোট চলক প্রাথমিক মান ডিফল্ট হিসাবে 1 হবে।

পরিবর্তনশীল ব্যাখ্যা

মোট: এটি ফানক দ্বারা ফিরে আসা সমষ্টি মান (সমষ্টিগত মান) ধরে রাখবে।

NextValue: এটি অ্যারে ক্রমের পরবর্তী মান। এই মানটি সমষ্টিগত মান হিসাবে মোট যোগ করা হয়।

উদাহরণ 2: একটি অ্যারেতে সমস্ত আইটেম যুক্ত করুন। 10 থেকে যোগ করা শুরু করতে প্রাথমিক সঞ্চয়ের মানটিও সেট করুন।

int[] numbers = new int[] { 1,2,3,4,5 };
int aggregatedValue = numbers.Aggregate(10, (total, nextValue) => total + nextValue);

যুক্তি ব্যাখ্যা:

প্রথম যুক্তিটি হ'ল প্রাথমিক (আরম্ভের মান অর্থাৎ বীজ মান) যা অ্যারেতে পরবর্তী মানের সাথে সংযোজন শুরু করতে ব্যবহৃত হবে।

দ্বিতীয় যুক্তিটি একটি ফানক যা একটি ফানক যা 2 ইন্টি লাগে takes

১. মোট: এটি গণনার পরে ফানক দ্বারা যোগ করা সমষ্টি মূল্য (সমষ্টিগত মান) আগের মতোই থাকবে।

2.nextValue:: এটি অ্যারে ক্রমের পরবর্তী মান। এই মানটি সমষ্টিগত মান হিসাবে মোট যোগ করা হয়।

এছাড়াও এই কোডটি ডিবাগ করা আপনাকে কীভাবে সামগ্রিক কাজ করবে তার আরও ভাল ধারণা দেবে।

— maxspan
সূত্র
7

জামিয়কের উত্তর থেকে অনেক কিছু শিখেছে ।

যদি কেবলমাত্র প্রয়োজন হয় CSV স্ট্রিং উত্পন্ন করা হয় তবে আপনি এটি ব্যবহার করতে পারেন।

var csv3 = string.Join(",",chars);

এখানে 1 মিলিয়ন স্ট্রিং সহ একটি পরীক্ষা রয়েছে

0.28 seconds = Aggregate w/ String Builder 
0.30 seconds = String.Join

উত্স কোড এখানে

— Rm558
সূত্র
আমি যখন লিঙ্কটিতে প্রদত্ত ডটনেটফিটালটনে একই কোডটি চালিয়েছিলাম তখন আমি "মারাত্মক ত্রুটি:" স্ট্রিং.জাইন "এর জন্য স্মৃতি ব্যবহারের সীমা অতিক্রম করেছিলাম তবে সমষ্টি সর্বদা প্রত্যাশা অনুযায়ী কাজ করেছিল। সুতরাং আমি বিশ্বাস করি যে এটি স্ট্রিং ব্যবহার করার জন্য প্রস্তাবিত নয় oin জয়েন
— মনিশ জৈন
স্ট্রেঞ্জ? যখন আমি প্রথম স্টপ ওয়াচটি মন্তব্য করেছিলাম যা সমষ্টি জন্য ছিল; তাহলে আমি কোনও "মারাত্মক ত্রুটি: মেমরির ব্যবহারের সীমা অতিক্রম করেছিলাম" পাচ্ছি না। দয়া করে ব্যাখ্যা করুন! লিঙ্ক: ডটনেটফিডাল.এন.
— মণীশ জৈন
এক্সপ্লোরেশন স্টপ পৌঁছানোর সময় ডটনেটফিডাল.নেটের একটি মেমরি সীমা থাকে। আপনি যদি স্ট্রিং.জাইন কোডের আগে সমষ্টিগত কোডটি সরিয়ে থাকেন তবে আপনি সামগ্রিকের জন্য ত্রুটি পেতে পারেন।
— Rm558
7

এখানে ইতিমধ্যে সমস্ত দুর্দান্ত উত্তরের পাশাপাশি, আমি এটি পরিবর্তন করে বিভিন্ন পদক্ষেপের মাধ্যমে কোনও আইটেম হাঁটাতেও ব্যবহার করেছি।

যদি রূপান্তর রূপে প্রয়োগ করা হয় Func<T,T>তবে আপনি একটিতে বেশ কয়েকটি রূপান্তর সংযোজন করতে পারেন List<Func<T,T>>এবং প্রতিটি পদক্ষেপের মধ্য দিয়ে Aggregateচলতে ব্যবহার করতে পারেন T।

আরও দৃ concrete় উদাহরণ

আপনি একটি stringমান নিতে চান এবং এটি পাঠ্য ট্রান্সফরমেশনগুলির একটি ধারাবাহিকের মধ্য দিয়ে চলতে পারেন যা অগ্রণীতভাবে নির্মিত যেতে পারে।

var transformationPipeLine = new List<Func<string, string>>();
transformationPipeLine.Add((input) => input.Trim());
transformationPipeLine.Add((input) => input.Substring(1));
transformationPipeLine.Add((input) => input.Substring(0, input.Length - 1));
transformationPipeLine.Add((input) => input.ToUpper());

var text = "    cat   ";
var output = transformationPipeLine.Aggregate(text, (input, transform)=> transform(input));
Console.WriteLine(output);

এটি রূপান্তরগুলির একটি শৃঙ্খলা তৈরি করবে: শীর্ষস্থানীয় এবং চলমান স্থানগুলি সরান -> প্রথম অক্ষর সরান -> শেষ চরিত্রটি সরান -> বড় হাতের অক্ষরে রূপান্তর করুন। যে কোনও ধরণের রূপান্তর পাইপলাইন প্রয়োজন হয় তা তৈরি করতে এই চেইনের পদক্ষেপগুলি যুক্ত করা যায়, মুছে ফেলা যায় বা প্রয়োজন অনুসারে পুনরায় সাজানো যায়।

এই নির্দিষ্ট পাইপলাইনের শেষ ফলাফল, এটি " cat "হয়ে যায় "A"।

এটি খুবই শক্তিশালী হয়ে একবার আপনি বুঝতে পারি যে করতে Tহতে পারে কিছু । এটি BitMapউদাহরণস্বরূপ ফিল্টারগুলির মতো চিত্র রূপান্তরের জন্য ব্যবহার করা যেতে পারে ;

— ব্র্যাডলি উফনার
সূত্র
4

সংজ্ঞা

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

সুতরাং, সমষ্টিগত পদ্ধতিটি একটি পুনরাবৃত্ত ফাংশনটি নিরাপদ বাস্তবায়নের একটি ফর্ম।

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

বাক্য গঠন:

collection.Aggregate(seed, func, resultSelector);
  • বীজ - ডিফল্ট হিসাবে প্রাথমিক মান;
  • func - আমাদের পুনরাবৃত্তি ফাংশন। এটি ল্যাম্বডা-এক্সপ্রেশন, ফানক প্রতিনিধি বা কোনও ফাংশনের ধরণের টিএফ (টি ফলাফল, টি নেক্সটভ্যালু) হতে পারে;
  • রেজাল্ট সিলেক্টর - এটি চূড়ান্ত ফলাফল গণনা, রূপান্তর, পরিবর্তন, রূপান্তর করতে ফানক বা একটি অভিব্যক্তির মতো একটি ফাংশন হতে পারে।

কিভাবে এটা কাজ করে:

var nums = new[]{1, 2};
var result = nums.Aggregate(1, (result, n) => result + n); //result = (1 + 1) + 2 = 4
var result2 = nums.Aggregate(0, (result, n) => result + n, response => (decimal)response/2.0); //result2 = ((0 + 1) + 2)*1.0/2.0 = 3*1.0/2.0 = 3.0/2.0 = 1.5

ব্যবহারিক ব্যবহার:

  1. একটি নম্বর থেকে কারখানাটি সন্ধান করুন:

int n = 7;
var numbers = Enumerable.Range(1, n);
var factorial = numbers.Aggregate((result, x) => result * x);

যা এই ফাংশন হিসাবে একই জিনিস করছে:

public static int Factorial(int n)
{
   if (n < 1) return 1;

   return n * Factorial(n - 1);
}
  1. সমষ্টি () নির্বাচন () এবং যেখানে () এর মতো সর্বাধিক শক্তিশালী লিনকিউ এক্সটেনশন পদ্ধতি। আমরা এর যোগফল (), ন্যূনতম () প্রতিস্থাপন করতে ব্যবহার করতে পারি। সর্বোচ্চ (), গড় () কার্যকারিতা বা সংযোজন প্রসঙ্গে প্রয়োগ করে এটি পরিবর্তন করতে:
    var numbers = new[]{3, 2, 6, 4, 9, 5, 7};
    var avg = numbers.Aggregate(0.0, (result, x) => result + x, response => (double)response/(double)numbers.Count());
    var min = numbers.Aggregate((result, x) => (result < x)? result: x);
  1. এক্সটেনশন পদ্ধতিগুলির আরও জটিল ব্যবহার:
    var path = @“c:\path-to-folder”;

    string[] txtFiles = Directory.GetFiles(path).Where(f => f.EndsWith(“.txt”)).ToArray<string>();
    var output = txtFiles.Select(f => File.ReadAllText(f, Encoding.Default)).Aggregate<string>((result, content) => result + content);

    File.WriteAllText(path + “summary.txt”, output, Encoding.Default);

    Console.WriteLine(“Text files merged into: {0}”, output); //or other log info
— YuriUn
সূত্র
বেশ ভাল প্রথম উত্তর। সাবাশ! লজ্জাজনক এটি এত পুরানো প্রশ্ন বা আপনি প্রচুর উপস্থাপনা পেয়ে যাবেন
— জামিয়েক
1

এটি Aggregateলিনক বাছাইয়ের মতো একটি সাবলীল এপিআইতে ব্যবহার সম্পর্কে একটি ব্যাখ্যা ।

var list = new List<Student>();
var sorted = list
    .OrderBy(s => s.LastName)
    .ThenBy(s => s.FirstName)
    .ThenBy(s => s.Age)
    .ThenBy(s => s.Grading)
    .ThenBy(s => s.TotalCourses);

এবং দেখতে দিন যে আমরা ক্ষেত্রের সেট নিয়ে একটি সাজানোর ক্রিয়াটি প্রয়োগ করতে চাই, এটি Aggregateলুপের পরিবর্তে এটির মতো খুব সহজে ব্যবহার করে:

public static IOrderedEnumerable<Student> MySort(
    this List<Student> list,
    params Func<Student, object>[] fields)
{
    var firstField = fields.First();
    var otherFields = fields.Skip(1);

    var init = list.OrderBy(firstField);
    return otherFields.Skip(1).Aggregate(init, (resultList, current) => resultList.ThenBy(current));
}

এবং আমরা এটি এর মতো ব্যবহার করতে পারি:

var sorted = list.MySort(
    s => s.LastName,
    s => s.FirstName,
    s => s.Age,
    s => s.Grading,
    s => s.TotalCourses);
— Jaider
সূত্র
1

প্রত্যেকেই তার ব্যাখ্যা দিয়েছেন। আমার ব্যাখ্যাটি এরকম।

সমষ্টি পদ্ধতি একটি সংকলনের প্রতিটি আইটেমের জন্য একটি ফাংশন প্রয়োগ করে। উদাহরণস্বরূপ, আসুন {6, 2, 8, 3 collection সংগ্রহ করুন এবং ফাংশনটি এটি যোগ করুন (অপারেটর +) এটি করে (((6 + 2) +8) +3) এবং ফেরত 19

var numbers = new List<int> { 6, 2, 8, 3 };
int sum = numbers.Aggregate(func: (result, item) => result + item);
// sum: (((6+2)+8)+3) = 19

এই উদাহরণে ল্যাম্বডা এক্সপ্রেশনের পরিবর্তে নামকরণ পদ্ধতি যুক্ত হয়েছে।

var numbers = new List<int> { 6, 2, 8, 3 };
int sum = numbers.Aggregate(func: Add);
// sum: (((6+2)+8)+3) = 19

private static int Add(int x, int y) { return x + y; }
— bizimunda
সূত্র
0

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

এইভাবে আপনি সংখ্যার ফ্যাক্টরিয়াল, বা স্ট্রাকটেন্ট স্ট্রিংগুলি গণনা করতে পারেন।

— সিরো করভিনো
সূত্র
0

সমষ্টি একাধিক মাত্রিক পূর্ণসংখ্যার অ্যারেতে কলামগুলি যোগ করতে ব্যবহৃত হত

        int[][] nonMagicSquare =
        {
            new int[] {  3,  1,  7,  8 },
            new int[] {  2,  4, 16,  5 },
            new int[] { 11,  6, 12, 15 },
            new int[] {  9, 13, 10, 14 }
        };

        IEnumerable<int> rowSums = nonMagicSquare
            .Select(row => row.Sum());
        IEnumerable<int> colSums = nonMagicSquare
            .Aggregate(
                (priorSums, currentRow) =>
                    priorSums.Select((priorSum, index) => priorSum + currentRow[index]).ToArray()
                );

সূচী সহ নির্বাচন করুন মিলিত কলামগুলি যোগ করতে এবং একটি নতুন অ্যারে ফিরিয়ে আনতে সামগ্রিক ফানকের মধ্যে ব্যবহার করা হয়; {3 + 2 = 5, 1 + 4 = 5, 7 + 16 = 23, 8 + 5 = 13}

        Console.WriteLine("rowSums: " + string.Join(", ", rowSums)); // rowSums: 19, 27, 44, 46
        Console.WriteLine("colSums: " + string.Join(", ", colSums)); // colSums: 25, 24, 45, 42

কিন্তু বুলিয়ান অ্যারেতে ট্রুর সংখ্যা গণনা আরও কঠিন কারণ যেহেতু সঞ্চিত প্রকার (ইন্ট) উত্সের ধরণের (বুল) থেকে পৃথক; দ্বিতীয় ওভারলোডটি ব্যবহার করার জন্য এখানে একটি বীজ প্রয়োজনীয়।

        bool[][] booleanTable =
        {
            new bool[] { true, true, true, false },
            new bool[] { false, false, false, true },
            new bool[] { true, false, false, true },
            new bool[] { true, true, false, false }
        };

        IEnumerable<int> rowCounts = booleanTable
            .Select(row => row.Select(value => value ? 1 : 0).Sum());
        IEnumerable<int> seed = new int[booleanTable.First().Length];
        IEnumerable<int> colCounts = booleanTable
            .Aggregate(seed,
                (priorSums, currentRow) =>
                    priorSums.Select((priorSum, index) => priorSum + (currentRow[index] ? 1 : 0)).ToArray()
                );

        Console.WriteLine("rowCounts: " + string.Join(", ", rowCounts)); // rowCounts: 3, 1, 2, 2
        Console.WriteLine("colCounts: " + string.Join(", ", colCounts)); // colCounts: 3, 2, 1, 2
— ড্যান এম
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.