आप एक int सरणी में निम्नतम मूल्य का सूचकांक कैसे प्राप्त करेंगे?

Question

यह मानते हुए कि यह एक बहुत ही बुनियादी कार्य है, मैं इसे करने का एक उचित तरीका नहीं सोच सकता था। आप int सरणी में निम्नतम मान का सूचकांक कैसे प्राप्त करेंगे? लिंक/मोरलिंक का उपयोग करना संभव है। मुझे अब तक एक उचित लाइनर नहीं मिला।

Answer 1

जब से तुम MoreLinq, के बारे में कैसे उल्लेख:

int[] array = .. 

// Will throw if the array is empty. 
// If there are duplicate minimum values, the one with the smaller 
// index will be chosen. 
int minIndex = array.AsSmartEnumerable() 
        .MinBy(entry => entry.Value) 
        .Index; 

एक अन्य विकल्प:

// Will throw if the array is empty. 
// Requires two passes over the array. 
int minIndex = Array.IndexOf(array, array.Min()); 

आप निश्चित रूप से अपने खुद के विस्तार-विधि लिख सकते हैं:

// Returns last index of the value that is the minimum. 
public static int IndexOfMin(this IEnumerable<int> source) 
{ 
    if(source == null) 
    throw new ArgumentNullException("source"); 

    int minValue = int.MaxValue; 
    int minIndex = -1; 
    int index = -1; 

    foreach(int num in source) 
    { 
     index++; 

     if(num <= minValue) 
     { 
     minValue = num; 
     minIndex = index; 
     } 
    } 

    if(index == -1) 
    throw new InvalidOperationException("Sequence was empty"); 

    return minIndex; 
} 

कुछ प्रयास के साथ , आप IComparer<T> को स्वीकार कर किसी भी प्रकार से इसे सामान्यीकृत कर सकते हैं,पर डिफॉल्ट।

Answer 2

बहुत स्मृति अनुकूल नहीं है, लेकिन ...

array.Select((n, i) => new { index = i, value = n }) 
    .OrderBy(item => item.value) 
    .First().index 

Answer 3

यह बदसूरत है, लेकिन यह केवल अनुक्रम के माध्यम से एक भी पास की जरूरत है और केवल का उपयोग करता है में निर्मित ढांचे तरीके:

int index = yourArray.Select((x, i) => new { Val = x, Idx = i }) 
        .Aggregate(new { Val = -1, Idx = -1 }, 
           (a, x) => (x.Idx == 0 || x.Val < a.Val) ? x : a, 
           x => x.Idx); 

और, जाहिर है, आप एक सामान्य प्रयोजन विस्तार विधि लिख सकते हैं:

int index = yourArray.MinIndex(); 

// ... 

public static class EnumerableExtensions 
{ 
    public static int MinIndex<T>(
     this IEnumerable<T> source, IComparer<T> comparer = null) 
    { 
     if (source == null) 
      throw new ArgumentNullException("source"); 

     if (comparer == null) 
      comparer = Comparer<T>.Default; 

     using (var enumerator = source.GetEnumerator()) 
     { 
      if (!enumerator.MoveNext()) 
       return -1; // or maybe throw InvalidOperationException 

      int minIndex = 0; 
      T minValue = enumerator.Current; 

      int index = 0; 
      while (enumerator.MoveNext()) 
      { 
       index++; 
       if (comparer.Compare(enumerator.Current, minValue) < 0) 
       { 
        minIndex = index; 
        minValue = enumerator.Current; 
       } 
      } 
      return minIndex; 
     } 
    } 
} 

Answer 4

LINQ शायद सबसे अच्छा समाधान च नहीं है या यह समस्या, लेकिन यहां एक और भिन्नता है जो ओ (एन) है। यह सॉर्ट नहीं करता है और केवल एक बार सरणी को घुमाता है।

var arr = new int[] { 3, 1, 0, 5 }; 
int pos = Enumerable.Range(0, arr.Length) 
    .Aggregate((a, b) => (arr[a] < arr[b]) ? a : b); // returns 2 

अद्यतन: मूल प्रश्न सीधे उत्तर देना, यह कैसे मैं यह कर देगी:

var arr = new int[] { 3, 1, 0, 5 }; 
int pos = 0; 
for (int i = 0; i < arr.Length; i++) 
{ 
    if (arr[i] < arr[pos]) { pos = i; } 
} 
// pos == 2 

नहीं, यह LINQ का उपयोग नहीं करता। हां, यह एक से अधिक पंक्ति है। लेकिन यह वास्तव में सरल और वास्तव में तेज़ है। इसे एक छोटी सी छोटी विधि में बनाएं और इसे किसी भी पंक्ति से कहीं भी कॉल करें: pos = FindMinIndex(arr);