Comment trier des chaînes par ordre alphabétique tout en tenant compte de la valeur lorsqu'une chaîne est numérique ?

Question

J'essaie de trier un tableau de chiffres qui sont des chaînes de caractères et je voudrais qu'ils soient triés numériquement.

Le problème est que Je n'arrive pas à convertir les chiffres en int .

Voici le code :

string[] things= new string[] { "105", "101", "102", "103", "90" };

foreach (var thing in things.OrderBy(x => x))
{
    Console.WriteLine(thing);
}

Sortie :

101, 102, 103, 105, 90

J'aimerais bien :

90, 101, 102, 103, 105

EDIT : La sortie ne peut pas être 090, 101, 102...

Mise à jour de l'exemple de code pour dire " things " au lieu de " sizes ". Le tableau peut être quelque chose comme ceci :

string[] things= new string[] { "paul", "bob", "lauren", "007", "90" };

Cela signifie qu'il doit être trié par ordre alphabétique et par numéro :

007, 90, bob, lauren, paul

Answer 1

Passez un comparateur personnalisé dans OrderBy. Enumerable.OrderBy vous permettra de spécifier le comparateur de votre choix.

C'est une façon de le faire :

void Main()
{
    string[] things = new string[] { "paul", "bob", "lauren", "007", "90", "101"};

    foreach (var thing in things.OrderBy(x => x, new SemiNumericComparer()))
    {    
        Console.WriteLine(thing);
    }
}

public class SemiNumericComparer: IComparer<string>
{
    /// <summary>
    /// Method to determine if a string is a number
    /// </summary>
    /// <param name="value">String to test</param>
    /// <returns>True if numeric</returns>
    public static bool IsNumeric(string value)
    {
        return int.TryParse(value, out _);
    }

    /// <inheritdoc />
    public int Compare(string s1, string s2)
    {
        const int S1GreaterThanS2 = 1;
        const int S2GreaterThanS1 = -1;

        var IsNumeric1 = IsNumeric(s1);
        var IsNumeric2 = IsNumeric(s2);

        if (IsNumeric1 && IsNumeric2)
        {
            var i1 = Convert.ToInt32(s1);
            var i2 = Convert.ToInt32(s2);

            if (i1 > i2)
            {
                return S1GreaterThanS2;
            }

            if (i1 < i2)
            {
                return S2GreaterThanS1;
            }

            return 0;
        }

        if (IsNumeric1)
        {
            return S2GreaterThanS1;
        }

        if (IsNumeric2)
        {
            return S1GreaterThanS2;
        }

        return string.Compare(s1, s2, true, CultureInfo.InvariantCulture);
    }
}

Answer 2

Il suffit d'ajouter des zéros de la même longueur :

int maxlen = sizes.Max(x => x.Length);
var result = sizes.OrderBy(x => x.PadLeft(maxlen, '0'));

Answer 3

Et, que pensez-vous de ça ...

string[] sizes = new string[] { "105", "101", "102", "103", "90" };

var size = from x in sizes
           orderby x.Length, x
           select x;

foreach (var p in size)
{
    Console.WriteLine(p);
}

Answer 4

Vous dites que vous ne pouvez pas convertir les nombres en int parce que le tableau peut contenir des éléments qui ne peuvent pas être convertis en int, mais il n'y a aucun mal à essayer :

string[] things = new string[] { "105", "101", "102", "103", "90", "paul", "bob", "lauren", "007", "90" };
Array.Sort(things, CompareThings);

foreach (var thing in things)
    Debug.WriteLine(thing);

Ensuite, comparez comme ceci :

private static int CompareThings(string x, string y)
{
    int intX, intY;
    if (int.TryParse(x, out intX) && int.TryParse(y, out intY))
        return intX.CompareTo(intY);

    return x.CompareTo(y);
}

Sortie : 007, 90, 90, 101, 102, 103, 105, bob, lauren, paul.

Answer 5

Cette demande semble bizarre et mérite une solution bizarre :

string[] sizes = new string[] { "105", "101", "102", "103", "90" };

foreach (var size in sizes.OrderBy(x => {
    double sum = 0;
    int position = 0;
    foreach (char c in x.ToCharArray().Reverse()) {
        sum += (c - 48) * (int)(Math.Pow(10,position));
        position++;
    }
    return sum;
}))

{
    Console.WriteLine(size);
}