I have an array list of List<string> that contains values in the following order ["1m", "1cm", "4km","2cm"] (Centimeters, meters and kilometers)

When I want to sort this array, I get a wrong answer. I use OrderBy:

List<string> data = new List<string> { "1m", "1cm", "4km","2cm" };
var result= data.OrderBy(x => x).ToList();

the result is:

{ "1cm", "1m", "2cm", "4km"}

But I want the answer to be this: { "1cm", "2cm", "1m", "4km"}

CodePudding user response：

You have sorted the data alphabetically. First the first character is compared. Then the second character and...

You need to normalize the data based on cm(or m) and then sort.

   List<string> data = new List<string> { "1m", "1cm", "4km","2cm" };
   var result = data.OrderBy(x => lenghtCM(x));

    public int lenghtCM(string lenghtStr)
    {
        if (lenghtStr.Contains("cm"))
        {
            string num = lenghtStr.Split("cm")[0];
            return int.Parse(num);
           
        } 
        else if (lenghtStr.Contains("km"))
        {
            string num = lenghtStr.Split("km")[0];
            return int.Parse(num) * 100*1000;
        }
        else if (lenghtStr.Contains("m"))
        {
            string num = lenghtStr.Split('m')[0];
            return int.Parse(num) * 100;
        }
        return 0;
    }

then the result:

{ "1cm", "2cm", "1m", "4km"}

CodePudding user response：

You need custom sort using IComparable

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication49
{
    
    class Program
    {
        static void Main(string[] args)
        {
            List<string> data = new List<string> { "1m", "1cm", "4km", "2cm" };
            List<string> results = data.Select(x => new SortDistance(x)).OrderBy(x => x).Select(x => x.value).ToList();

        }
    }
    public class SortDistance : IComparable<SortDistance>
    {
        const string pattern = @"(?'number'\d )(?'multiplier'.*)";
        List<string> distanceOrder = new List<string>() { "cm", "m", "km" };
        public string value { get; set; }
        public int distance { get; set; }
        public string multiplier { get; set; }

        public SortDistance(string value)
        {
            this.value = value;
            Match match = Regex.Match(value, pattern);
            this.distance = int.Parse(match.Groups["number"].Value);
            this.multiplier = match.Groups["multiplier"].Value;
        }
        public int CompareTo(SortDistance other)
        {
            if (this.multiplier == other.multiplier)
                return this.distance.CompareTo(other.distance);
            else
                return distanceOrder.IndexOf(this.multiplier).CompareTo(distanceOrder.IndexOf(other.multiplier));
        }
    }
}

CodePudding user response：

you can not sort using OrderBy.

You have to define the conversion first from all units to the smallest unit. for example m to cm, km to cm.....

so 1m euqals to 100 cm

then you have to iterate through your list and check each item's unit, get its equivalent to the smallest unit.

Create another list.

you can implement insertion sort to sort the items and add keep on inserting the item based on the comparison.

CodePudding user response：

If you can, parse the strings first:

enum Unit { cm, m, km }

record Measurment(int Length, Unit Unit)
{
    public override string ToString() => $"{Length}{Enum.GetName(typeof(Unit), Unit)}";

    public double NormalizedLength => Unit switch
    {
        Unit.cm => Length * 0.001,
        Unit.m => Length * 1.0,
        Unit.km => Length * 1000.0,
        _ => throw new NotImplementedException()
    };

    public static Measurment Parse(string source)
    {
        var digits = source.TakeWhile(char.IsDigit).Count();
        var length = int.Parse(source.AsSpan(0, digits));

        // switches with source.AsSpan(digits) in preview
        var measure = source[..digits] switch
        {
            "cm" => Unit.cm,
            "m" => Unit.m,
            "km" => Unit.km,
            _ => throw new NotImplementedException(),
        };
        return new Measurment(length, measure);
    }
}

.

var result = data.Select(Measurment.Parse).OrderBy(x => x.NormalizedLength).ToList();

This lets you sort your measurments by NormalizedLength and ToString gets back the original string. Should be very fast, simple to extend with new units and you can make it fault-tolerant if you turn Parse into the TryParse pattern.

CodePudding user response：

There's a NuGet package to manage parsing and manipulating SI units called UnitsNet.

If you install that package (via Add | NuGet Package, search for and select UnitsNet and install it), then you can write the following code:

(You'll need to add using UnitsNet; at the top of the code file first)

This also works with nm etc.

List<string> data = new List<string> { "1m", "1cm", "4km", "2cm" };

var result = data.OrderBy(Length.Parse).ToList();

Console.WriteLine(string.Join(", ", result));

This will output "1cm, 2cm, 1m, 4km"