C # उच्चतम सरणी मान और सूचकांक खोजें

Question 1

इसलिए मेरे पास एक असंक्रमित संख्यात्मक सरणी है int[] anArray = { 1, 5, 2, 7 };और मुझे सरणी में सबसे बड़े मूल्य के मूल्य और सूचकांक दोनों को प्राप्त करने की आवश्यकता है जो 7 और 3 होगी, मैं यह कैसे करूंगा?

Question 2

यह सबसे ग्लैमरस तरीका नहीं है, लेकिन काम करता है।

(होना चाहिए using System.Linq;)

 int maxValue = anArray.Max();
 int maxIndex = anArray.ToList().IndexOf(maxValue);

Question 3

int[] anArray = { 1, 5, 2, 7 };
// Finding max
int m = anArray.Max();

// Positioning max
int p = Array.IndexOf(anArray, m);

Question 4

यदि अनुक्रमणिका क्रमबद्ध नहीं है, तो आपको उच्चतम मान ज्ञात करने के लिए कम से कम एक बार सरणी के माध्यम से पुनरावृत्त करना होगा। मैं एक साधारण forलूप का उपयोग करता हूं :

int? maxVal = null; //nullable so this works even if you have all super-low negatives
int index = -1;
for (int i = 0; i < anArray.Length; i++)
{
  int thisNum = anArray[i];
  if (!maxVal.HasValue || thisNum > maxVal.Value)
  {
    maxVal = thisNum;
    index = i;
  }
}

यह LINQ या अन्य वन-लाइन समाधानों का उपयोग करने की तुलना में अधिक क्रिया है, लेकिन यह शायद थोड़ा तेज है। ओ (एन) की तुलना में इस तेजी से बनाने का कोई तरीका नहीं है।

Question 5

अनिवार्य LINQ एक ^[1] -लाइनर:

var max = anArray.Select((value, index) => new {value, index})
                 .OrderByDescending(vi => vi.value)
                 .First();

(छँटाई शायद अन्य समाधानों पर एक प्रदर्शन हिट है।)

[१]: "एक" के दिए गए मूल्यों के लिए।

Question 6

एक रसीला एक-लाइनर:

var max = anArray.Select((n, i) => (Number: n, Index: i)).Max();

परीक्षण का मामला:

var anArray = new int[] { 1, 5, 2, 7 };
var max = anArray.Select((n, i) => (Number: n, Index: i)).Max();
Console.WriteLine($"Maximum number = {max.Number}, on index {max.Index}.");
// Maximum number = 7, on index 4.

विशेषताएं:

Linq का उपयोग करता है (वेनिला के रूप में अनुकूलित नहीं है, लेकिन व्यापार बंद कोड कम है)।
छाँटने की जरूरत नहीं है।
कम्प्यूटेशनल जटिलता: ओ (एन)।
अंतरिक्ष की जटिलता: O (n)।

टिप्पणियों:

सुनिश्चित करें कि संख्या (और सूचकांक नहीं) टुपल में पहला तत्व है क्योंकि ट्यूपल की छंटाई टुपल वस्तुओं को बाएं से दाएं की तुलना करके की जाती है।

Question 7

यहाँ दो दृष्टिकोण हैं। सरणी खाली होने पर आप हैंडलिंग को जोड़ना चाह सकते हैं।

public static void FindMax()
{
    // Advantages: 
    // * Functional approach
    // * Compact code
    // Cons: 
    // * We are indexing into the array twice at each step
    // * The Range and IEnumerable add a bit of overhead
    // * Many people will find this code harder to understand

    int[] array = { 1, 5, 2, 7 };

    int maxIndex = Enumerable.Range(0, array.Length).Aggregate((max, i) => array[max] > array[i] ? max : i);
    int maxInt = array[maxIndex];

    Console.WriteLine($"Maximum int {maxInt} is found at index {maxIndex}");
}

public static void FindMax2()
{
    // Advantages: 
    // * Near-optimal performance

    int[] array = { 1, 5, 2, 7 };
    int maxIndex = -1;
    int maxInt = Int32.MinValue;

    // Modern C# compilers optimize the case where we put array.Length in the condition
    for (int i = 0; i < array.Length; i++)
    {
        int value = array[i];
        if (value > maxInt)
        {
            maxInt = value;
            maxIndex = i;
        }
    }

    Console.WriteLine($"Maximum int {maxInt} is found at index {maxIndex}");
}

Question 8

anArray.Select((n, i) => new { Value = n, Index = i })
    .Where(s => s.Value == anArray.Max());

Question 9

int[] numbers = new int[7]{45,67,23,45,19,85,64}; 
int smallest = numbers[0]; 
for (int index = 0; index < numbers.Length; index++) 
{ 
 if (numbers[index] < smallest) smallest = numbers[index]; 
} 
Console.WriteLine(smallest);

Question 10

बेलो कोड के लिए आउटपुट:

00: 00: 00.3279270 - अधिकतम 1 00: 00: 00.2615935 - अधिकतम 2 00: 00: 00.6010360 - max3 (arr.Max ())

100000000 ints के साथ सरणी में बहुत बड़ा अंतर नहीं है लेकिन फिर भी ...

class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[100000000];

            Random randNum = new Random();
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = randNum.Next(-100000000, 100000000);
            }
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            Stopwatch stopwatch3 = new Stopwatch();
            stopwatch1.Start();

            var max = GetMaxFullIterate(arr);

            Debug.WriteLine( stopwatch1.Elapsed.ToString());


            stopwatch2.Start();
            var max2 = GetMaxPartialIterate(arr);

            Debug.WriteLine( stopwatch2.Elapsed.ToString());

            stopwatch3.Start();
            var max3 = arr.Max();
            Debug.WriteLine(stopwatch3.Elapsed.ToString());

        }



 private static int GetMaxPartialIterate(int[] arr)
        {
            var max = arr[0];
            var idx = 0;
            for (int i = arr.Length / 2; i < arr.Length; i++)
            {
                if (arr[i] > max)
                {
                    max = arr[i];
                }

                if (arr[idx] > max)
                {
                    max = arr[idx];
                }
                idx++;
            }
            return max;
        }


        private static int GetMaxFullIterate(int[] arr)
        {
            var max = arr[0];
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] > max)
                {
                    max = arr[i];
                }
            }
            return max;
        }

Question 11

 public static class ArrayExtensions
{
    public static int MaxIndexOf<T>(this T[] input)
    {
        var max = input.Max();
        int index = Array.IndexOf(input, max);
        return index;
    }
}

यह सभी प्रकार के चर के लिए काम करता है ...

var array = new int[]{1, 2, 4, 10, 0, 2};
var index = array.MaxIndexOf();


var array = new double[]{1.0, 2.0, 4.0, 10.0, 0.0, 2.0};
var index = array.MaxIndexOf();

Question 12

public static void Main()
{
    int a,b=0;
    int []arr={1, 2, 2, 3, 3, 4, 5, 6, 5, 7, 7, 7, 100, 8, 1};

    for(int i=arr.Length-1 ; i>-1 ; i--)
        {
            a = arr[i];

            if(a > b)
            {
                b=a;    
            }
        }
    Console.WriteLine(b);
}

Question 13

int[] Data= { 1, 212, 333,2,12,3311,122,23 };
int large = Data.Max();
Console.WriteLine(large);

Question 14

यहाँ एक LINQ समाधान है जो O (n) सभ्य स्थिर कारकों के साथ है:

int[] anArray = { 1, 5, 2, 7, 1 };

int index = 0;
int maxIndex = 0;

var max = anArray.Aggregate(
    (oldMax, element) => {
        ++index;
        if (element <= oldMax)
            return oldMax;
        maxIndex = index;
        return element;
    }
);

Console.WriteLine("max = {0}, maxIndex = {1}", max, maxIndex);

लेकिन आपको वास्तव में एक स्पष्ट forलोप लिखना चाहिए यदि आप प्रदर्शन के बारे में परवाह करते हैं।

Question 15

बस एक और परिप्रेक्ष्य का उपयोग कर DataTable। DataTable2 कॉलम के साथ घोषित करें indexऔर val। एक जोड़े AutoIncrementविकल्प और दोनों AutoIncrementSeedऔर AutoIncrementStepमूल्यों 1के लिए indexस्तंभ। फिर एक foreachलूप का उपयोग करें और प्रत्येक सरणी आइटम datatableको एक पंक्ति के रूप में डालें । फिर Selectविधि का उपयोग करके , अधिकतम मान वाली पंक्ति का चयन करें।

कोड

int[] anArray = { 1, 5, 2, 7 };
DataTable dt = new DataTable();
dt.Columns.AddRange(new DataColumn[2] { new DataColumn("index"), new DataColumn("val")});
dt.Columns["index"].AutoIncrement = true;
dt.Columns["index"].AutoIncrementSeed = 1;
dt.Columns["index"].AutoIncrementStep = 1;
foreach(int i in anArray)
    dt.Rows.Add(null, i);

DataRow[] dr = dt.Select("[val] = MAX([val])");
Console.WriteLine("Max Value = {0}, Index = {1}", dr[0][1], dr[0][0]);

उत्पादन

Max Value = 7, Index = 4

यहां एक डेमो खोजें

Question 16

सरणी में सबसे बड़ी और सबसे छोटी संख्या पाता है:

int[] arr = new int[] {35,28,20,89,63,45,12};
int big = 0;
int little = 0;

for (int i = 0; i < arr.Length; i++)
{
    Console.WriteLine(arr[i]);

    if (arr[i] > arr[0])
    {
        big = arr[i];
    }
    else
    {
        little = arr[i];

    }
}

Console.WriteLine("most big number inside of array is " + big);
Console.WriteLine("most little number inside of array is " + little);

Question 17

यदि आप जानते हैं कि अधिकतम मूल्य का अधिकतम सूचकांक तत्काल है। तो आप सभी की जरूरत अधिकतम सूचकांक है।

int max=0;

for(int i = 1; i < arr.Length; i++)
    if (arr[i] > arr[max]) max = i;

Question 18

यह एक C # वर्जन है। यह सरणी को सॉर्ट करने के विचार पर आधारित है।

public int solution(int[] A)
 {
    // write your code in C# 6.0 with .NET 4.5 (Mono)
    Array.Sort(A);
    var max = A.Max();
    if(max < 0)
        return 1;
    else
        for (int i = 1; i < max; i++)
        {
            if(!A.Contains(i)) {
                return i;
            }
        }
    return max + 1;
}

Question 19

निम्नलिखित पर विचार करें:

    /// <summary>
    /// Returns max value
    /// </summary>
    /// <param name="arr">array to search in</param>
    /// <param name="index">index of the max value</param>
    /// <returns>max value</returns>
    public static int MaxAt(int[] arr, out int index)
    {
        index = -1;
        int max = Int32.MinValue;

        for (int i = 0; i < arr.Length; i++)
        {
            if (arr[i] > max)
            { 
                max = arr[i];
                index = i;
            }
        }

        return max;
    }

उपयोग:

int m, at;
m = MaxAt(new int[]{1,2,7,3,4,5,6}, out at);
Console.WriteLine("Max: {0}, found at: {1}", m, at);

Question 20

forयदि हम गोल्फ की ओर जा रहे हैं, तो यह शरीरहीन पाश के साथ किया जा सकता है ;)

//a is the array


int mi = a.Length - 1;
for (int i=-1; ++i<a.Length-1; mi=a[mi]<a[i]?i:mi) ;

++i<a.Length-1आखिरी इंडेक्स की जांच करने वाले ओईट्स की जांच। हमें इससे कोई आपत्ति नहीं है अगर हम इसे सेट करते हैं जैसे कि अधिकतम इंडेक्स अंतिम इंडेक्स है जिसके साथ शुरू करना है। जब अन्य तत्वों के लिए लूप चलता है तो यह समाप्त हो जाएगा और एक या दूसरी बात सच है:

हमें एक नया अधिकतम मूल्य मिला और इसलिए एक नया अधिकतम सूचकांक mi
अंतिम सूचकांक सभी के साथ अधिकतम मूल्य था, इसलिए हमें एक नया नहीं मिला mi, और हम प्रारंभिक के साथ अटक गएmi

असली काम लूप पोस्ट-पोस्ट मॉडिफायर द्वारा किया जाता है:

क्या अधिकतम मूल्य ( a[mi]यानी द्वारा अनुक्रमित सरणी mi) हमें अब तक मिली, वर्तमान वस्तु से कम है?
- हाँ, फिर miयाद करके एक नया संग्रह करें i,
- नहीं तो मौजूदा स्टोर mi(नो-ऑप)

ऑपरेशन के अंत में आपके पास सूचकांक है जिस पर अधिकतम पाया जाना है। तार्किक रूप से तब अधिकतम मूल्य होता हैa[mi]

मैं यह नहीं देख सकता कि "अधिकतम मान और अधिकतम का सूचकांक कैसे प्राप्त करें" वास्तव में अधिकतम मूल्य को भी ट्रैक करने की आवश्यकता है, यह देखते हुए कि यदि आपके पास एक सरणी है, और आप अधिकतम मूल्य के सूचकांक को जानते हैं, तो अधिकतम मूल्य का वास्तविक मूल्य सूचकांक को अनुक्रमित करने के लिए सरणी का उपयोग करने का एक तुच्छ मामला है ।।