सी # में विभिन्न अवधि की दो सूचियां जोड़ें

Question

List<double> a = new List<double>{1,2,3}; 
List<double> b = new List<double>{1,2,3,4,5}; 

ए + बी मुझे 2,4,6,4,5

obvisouly मैं एक पाश लिखने लेकिन वहाँ एक बेहतर तरीका है सकते हैं देना चाहिए? linq का उपयोग कर?

Answer 1

आप आसानी से पर्याप्त एक संशोधित "ज़िप" आपरेशन इस्तेमाल कर सकते हैं, लेकिन कुछ नहीं में बनाया तरह:।

static void Main() { 
     var a = new List<int> { 1, 2, 3 }; 
     var b = new List<int> { 1, 2, 3, 4, 5 }; 
     foreach (var c in a.Merge(b, (x, y) => x + y)) { 
      Console.WriteLine(c); 
     } 
    } 
    static IEnumerable<T> Merge<T>(this IEnumerable<T> first, 
      IEnumerable<T> second, Func<T, T, T> operation) { 
     using (var iter1 = first.GetEnumerator()) 
     using (var iter2 = second.GetEnumerator()) { 
      while (iter1.MoveNext()) { 
       if (iter2.MoveNext()) { 
        yield return operation(iter1.Current, iter2.Current); 
       } else { 
        yield return iter1.Current; 
       } 
      } 
      while (iter2.MoveNext()) { 
       yield return iter2.Current; 
      } 
     } 
    } 

Answer 2

नीचे अपनी समस्या का समाधान है।

List<double> a = new List<double>{1,2,3}; 
List<double> b = new List<double>{1,2,3,4,5}; 

List<double> sum = new List<double>(); 
int max = Math.Min(a.Count, b.Count); 
for (int i = 0; i < max; i++){ 
    sum.Add(a[i] + b[i]); 
} 

if (a.Count < b.Count) 
    for (int i = max i < b.Count) 
     sum.Add(b[i]); 
else 
    for (int i = max i < a.Count) 
    sum.Add(a[i]); 

Answer 3

इस मामले में, क्या सूचियां समान लंबाई या विभिन्न लंबाई के हैं, यह वास्तव में कोई फर्क नहीं पड़ता। .NET क्लास लाइब्रेरी में 0 अनुक्रमों को गठबंधन करने के लिए Enumerable.Zip विधि नहीं है (यह केवल .NET 4.0 में आ जाएगा), और आपको किसी भी तरह से इस तरह की आवश्यकता होगी। तो आपको या तो एक लूप लिखना होगा, या अपना खुद का Zip लिखना होगा (जिसमें अभी भी एक लूप शामिल होगा)।

कुछ हैक्स को बिना किसी लूप के एक LINQ क्वेरी में निचोड़ने के लिए, इंडेक्स पर शामिल होने सहित, लेकिन वे बहुत धीमे और वास्तव में व्यर्थ होंगे।

Answer 4

1 और अतिरिक्त 2 और 3 पर क्या हुआ? आप अलग-अलग मान लिए देख रहे हैं:

var one = new List<int> { 1, 2, 3 }; 
var two = new List<int> { 1, 2, 3, 4, 5 }; 

foreach (var x in one.Union(two)) Console.Write("{0} ", x); 

आप 1 2 3 4 5

देंगे तुम सिर्फ दूसरा तो पहले से संलग्न सूची के लिए देख रहे हैं:

foreach(var x in one.Concat(two)) // ... 

आप दे देंगे 1 2 3 1 2 3 4 5

संपादित: ओह, मैं देख रहा हूँ, आपके एक प्रकार के लिए देख रहे हैं, लेकिन जो अतिरिक्त भागों को लौटाता है।इस प्रयास करें:

public static IEnumerable<V> Zip<T, U, V>(
    this IEnumerable<T> one, 
    IEnumerable<U> two, 
    Func<T, U, V> f) 
{ 
    using (var oneIter = one.GetEnumerator()) { 
     using (var twoIter = two.GetEnumerator()) { 
      while (oneIter.MoveNext()) { 
       twoIter.MoveNext(); 
       yield return f(oneIter.Current, 
        twoIter.MoveNext() ? 
         twoIter.Current : 
         default(U)); 
      } 

      while (twoIter.MoveNext()) { 
       yield return f(oneIter.Current, twoIter.Current); 
      } 
     } 
    } 
} 

और यहाँ एक और एक सामान्य जिप समारोह की तरह है कि, जो अतिरिक्त वापस नहीं करता है:

public static IEnumerable<V> Zip<T, U, V>(
    this IEnumerable<T> one, 
    IEnumerable<U> two, 
    Func<T, U, V> f) 
{ 
    using (var oneIter = one.GetEnumerator()) { 
     using (var twoIter = two.GetEnumerator()) { 
      while (oneIter.MoveNext()) { 
       yield return f(oneIter.Current, 
        twoIter.MoveNext() ? 
         twoIter.Current : 
         default(U)); 
      } 
     } 
    } 
} 

उदाहरण उपयोग:

var one = new List<int> { 1, 2, 3, 4, 5}; 
var two = new List<char> { 'h', 'e', 'l', 'l', 'o' }; 

foreach (var x in one.Zip(two, (a,b) => new {A = a, B =b })) 
    Console.WriteLine("{0} => '{1}'", x.A, x.B); 

में परिणाम :

1 => 'एच'
2 => 'ई'
3 => 'l'
4 => 'l'
5 => 'o'

Answer 5

एक पाश का उपयोग कर मेरे कार्यान्वयन:

List<double> shorter, longer; 
if (a.Count > b.Count) 
{ 
    shorter = b; longer = a 
} 
else 
{ 
    shorter = a; longer = b; 
} 

List<double> result = new List<double>(longer); 
for (int i = 0; i < shorter.Count; ++i) 
{ 
    result[i] += shorter[i]; 
} 

Answer 6

बदसूरत LINQ समाधान:

var sum = Enumerable.Range(0, (a.Count > b.Count) ? a.Count : b.Count) 
    .Select(i => (a.Count > i && b.Count > i) ? a[i] + b[i] : (a.Count > i) ? a[i] : b[i]); 

Answer 7

Enumerable.Range(0, new[] { a.Count, b.Count }.Max()) 
    .Select(n => a.ElementAtOrDefault(n) + b.ElementAtOrDefault(n));

Answer 8

.NET 4.0 के Zip ऑपरेटर का उपयोग करना:

var sums = b.Zip(a, (x, y) => x + y) 
      .Concat(b.Skip(a.Count())); 

यदि आप इसे सामान्य बनाना चाहते हैं, तो जांच करें कि किस तत्व में अधिक तत्व हैं और इसका उपयोग "बी" के रूप में करें।

Answer 9

कैसे इस बारे में:

List<double> doubles = Enumerable.Range(0, Math.Max(a.Count, b.Count)) 
    .Select(x => (a.Count > x ? a[x] : 0) + (b.Count > x ? b[x] : 0)) 
    .ToList(); 

Answer 10

यहां 3 और भी है:

सूचियों एक ही आकार है, तो बस साधारण का चयन करें।

(a.Count < b.Count ? a : b).AddRange(new double[Math.Abs(a.Count - b.Count)]); 
var c = a.Select((n, i) => n + b[i]); 

उन्हें एक ही आकार मत करना, लेकिन सबसे लंबे समय तक के माध्यम से जाने के लिए और कम से कम (आसान पर्फ़ लाभ के लिए दुकान shortList.Count) पर सीमा की समाप्ति के लिए जाँच:

var longList = a.Count > b.Count ? a : b; 
var shortList = longList == a ? b : a; 
var c = longList.Select((n, i) => n + (shortList.Count > i ? shortList[i] : 0)); 

Take जबकि आप कर सकते हैं, तो Skip और Union बाकी:

var c = a.Take(Math.Min(a.Count, b.Count)) 
     .Select((n, i) => n + b[i]) 
     .Union(a.Skip(Math.Min(a.Count, b.Count)); 

Answer 11

मैं थोड़ा अलग Ty की सूची के लिए अनुमति देने के लिए अपने प्रयोग के लिए मार्क के समाधान को समायोजित करने के लिए किया था पेस, तो मैंने सोचा कि मैं किसी और को परेशान करने में पोस्ट करूंगा।

public static IEnumerable<TResult> Merge<TFirst,TSecond,TResult>(this IEnumerable<TFirst> first, 
      IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> operation) { 
    using (var iter1 = first.GetEnumerator()) { 
     using (var iter2 = second.GetEnumerator()) { 
      while (iter1.MoveNext()) { 
       if (iter2.MoveNext()) { 
        yield return operation(iter1.Current, iter2.Current); 
       } else { 
        yield return operation(iter1.Current, default(TSecond)); 
       } 
      } 
      while (iter2.MoveNext()) { 
       yield return operation(default(TFirst), iter2.Current); 
      } 
     } 
    } 
}