C# trouver la valeur la plus élevée d'un tableau et son index

Question

J'ai donc un tableau numérique non trié int[] anArray = { 1, 5, 2, 7 }; et j'ai besoin d'obtenir à la fois la valeur et l'index de la plus grande valeur dans le tableau qui serait 7 et 3, comment dois-je faire ?

Answer 1

Juste une autre perspective utilisant DataTable . Déclarer un DataTable avec 2 colonnes appelées index y val . Ajouter un AutoIncrement et les deux AutoIncrementSeed y AutoIncrementStep valeurs 1 à la index colonne. Utilisez ensuite un foreach et insérer chaque élément du tableau dans le datatable comme une rangée. Ensuite, en utilisant Select sélectionnez la ligne ayant la valeur maximale.

Code

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]);

Sortie

Max Value = 7, Index = 4

Trouvez une démo ici

Answer 2

Il s'agit d'une version C#. Elle est basée sur l'idée de trier le tableau.

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;
}

Answer 3

Cela peut être fait avec une machine sans corps. for boucle, si nous nous dirigeons vers le golf ;)

//a is the array

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

Le contrôle de ++i<a.Length-1 omet de vérifier le dernier indice. Cela ne nous dérange pas si nous le configurons comme si l'indice maximum était le dernier indice au départ Lorsque la boucle s'exécute pour les autres éléments, elle se termine et l'une ou l'autre chose est vraie :

• nous avons trouvé une nouvelle valeur max et donc un nouvel indice max mi
• le dernier indice était la valeur maximale depuis le début, donc nous n'avons pas trouvé une nouvelle mi et nous nous en sommes tenus à la version initiale mi

Le véritable travail est effectué par les modificateurs post-boucle :

• est la valeur maximale ( a[mi] c'est-à-dire le tableau indexé par mi ) que nous avons trouvé jusqu'à présent, moins que l'article actuel ?
  • oui, alors enregistrez un nouveau mi en se souvenant i ,
  • non, alors stockez les mi (no-op)

A la fin de l'opération, vous avez l'indice auquel le maximum doit être trouvé. Logiquement, la valeur maximale est donc a[mi]

Je ne voyais pas vraiment comment le "find max and index of max" avait besoin de suivre la valeur maximale aussi, étant donné que si vous avez un tableau, et que vous connaissez l'index de la valeur maximale, la valeur réelle de la valeur maximale est un cas trivial d'utilisation de l'index pour indexer le tableau

Answer 4

Une autre réponse dans cette longue liste, mais je pense qu'elle en vaut la peine, car elle offre certains avantages que la plupart (ou toutes ?) les autres réponses n'offrent pas :

1. La méthode ci-dessous ne boucle qu'une seule fois dans la collection, l'ordre est donc le suivant O(N) .
2. La méthode trouve Tous les indices des valeurs maximales.
3. Cette méthode peut être utilisée pour trouver le les indices de toute comparaison : min , max , equals , not equals etc.
4. La méthode peut regarder dans les objets via un sélecteur LINQ.

Méthode :

///-------------------------------------------------------------------
/// <summary>
/// Get the indices of all values that meet the condition that is defined by the comparer.
/// </summary>
/// <typeparam name="TSource">The type of the values in the source collection.</typeparam>
/// <typeparam name="TCompare">The type of the values that are compared.</typeparam>
/// <param name="i_collection">The collection of values that is analysed.</param>
/// <param name="i_selector">The selector to retrieve the compare-values from the source-values.</param>
/// <param name="i_comparer">The comparer that is used to compare the values of the collection.</param>
/// <returns>The indices of all values that meet the condition that is defined by the comparer.</returns>
/// Create <see cref="IComparer{T}"/> from comparison function:
///   Comparer{T}.Create ( comparison )
/// Comparison examples:
/// - max:      (a, b) => a.CompareTo (b)
/// - min:      (a, b) => -(a.CompareTo (b))
/// - == x:     (a, b) => a == 4 ? 0 : -1
/// - != x:     (a, b) => a != 4 ? 0 : -1
///-------------------------------------------------------------------
public static IEnumerable<int> GetIndices<TSource, TCompare> (this IEnumerable<TSource> i_collection,
                                                                   Func<TSource, TCompare> i_selector,
                                                                   IComparer<TCompare> i_comparer)
{
  if (i_collection == null)
    throw new ArgumentNullException (nameof (i_collection));
  if (!i_collection.Any ())
    return new int[0];

  int index = 0;
  var indices = new List<int> ();
  TCompare reference = i_selector (i_collection.First ());

  foreach (var value in i_collection)
  {
    var compare = i_selector (value);
    int result = i_comparer.Compare (compare, reference);
    if (result > 0)
    {
      reference = compare;
      indices.Clear ();
      indices.Add (index);
    }
    else if (result == 0)
      indices.Add (index);

    index++;
  }

  return indices;
}

Si vous n'avez pas besoin du sélecteur, changez la méthode en

public static IEnumerable<int> GetIndices<TCompare> (this IEnumerable<TCompare> i_collection,
                                                          IComparer<TCompare> i_comparer)

et supprimer toutes les occurrences de i_selector .

Preuve de concept :

//########## test #1: int array ##########
int[] test = { 1, 5, 4, 9, 2, 7, 4, 6, 5, 9, 4 };

// get indices of maximum:
var indices = test.GetIndices (t => t, Comparer<int>.Create ((a, b) => a.CompareTo (b)));
// indices: { 3, 9 }

// get indices of all '4':
indices = test.GetIndices (t => t, Comparer<int>.Create ((a, b) => a == 4 ? 0 : -1));
// indices: { 2, 6, 10 }

// get indices of all except '4':
indices = test.GetIndices (t => t, Comparer<int>.Create ((a, b) => a != 4 ? 0 : -1));
// indices: { 0, 1, 3, 4, 5, 7, 8, 9 }

// get indices of all '15':
indices = test.GetIndices (t => t, Comparer<int>.Create ((a, b) => a == 15 ? 0 : -1));
// indices: { }

//########## test #2: named tuple array ##########
var datas = new (object anything, double score)[]
{
  (999,               0.1),
  (new object (),     0.42),
  ("hello",           0.3),
  (new Exception (),  0.16),
  ("abcde",           0.42)
};
// get indices of highest score:
indices = datas.GetIndices (data => data.score, Comparer<double>.Create ((a, b) => a.CompareTo (b)));
// indices: { 1, 4 }

Profitez-en ! :-)

Answer 5

Trouve le plus grand et le plus petit nombre dans le tableau :

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);