Sort string array in special style

You have one big string array which contains all of your player details. This is not the best solution.

Create player objects which contains all of the properties and put that in an array.

Then you can create custom sorting.

Player object:

public class Player {
     public string Type { get; set; }
     public string Gender { get; set; }
     public int AmountOfPlayers { get; set; }
     public int Order { get; set; }
}

Create your array list of Player objects:

List<Player> list = new List<Player>();
list.Add(new Player() { Type = "swim", Gender = "women", AmountOfPlayers = 3, Order = 1 });
list.Add(new Player() { Type = "soccer", Gender = "men", AmountOfPlayers = 12, Order = 4 });
list.Add(new Player() { Type = "volleyball", Gender = "men", AmountOfPlayers = 12, Order = 3 });
list.Add(new Player() { Type = "baseball", Gender = "men", AmountOfPlayers = 13, Order = 2 });

Sorting:

var sortedList = list.OrderBy(c => c.Order);

While I would suggest the Object oriented approach as illustrated by others. However just in case due to some reservations you cannot do that then this will work.

string[] players = new string[15] {"soccer","12","man","swim","3","woman","volleyball","12","man","baseball","13","man"
    ,"chess","18","man"};
string[] sort = new string[4] {"swim","baseball","volleyball","soccer"};
string[] playersSorted= new string[sort.Length*3];
int destStartIndex = 0;
foreach(string str in sort)
{
  int sourceStartIndex = Array.IndexOf(players,str);
  Array.Copy(players, sourceStartIndex, playersSorted, destStartIndex, 3);
  destStartIndex += 3;
}

DEMO

You can try this way. First create a class out of initial string[], which can represent all the values in a format shown below:

Class Sport
{
   public string Name {get; set;}
   public int Number {get; set;}
   public string Gender {get; set;}
}

Once you have the collection as List<Sport> sportList, now you need to create a custom IComparer to do the necessary sorting:

class SportSorter : IComparer<Sport>
{           
    public int Compare(Sport x, Sport y )
    {
        int retVal = 0;            
        retVal = string.Compare(x.Name,y.Name);
        return retVal;
    }
}

Now simply you can call by using the instance of SportSorter

SportSorter ss = new SportSorter();

sportList.Sort(ss);

Please note right now I am using Name property to Sort, same can be changed in CustomSorter (IComparer) code. This is a stable version of sort as compared to OrderBy, which use QuickSort. In case you want to chain multiple sorters in different directions together then check the following response:

Sort List of Dictionary using IComparer instead of OrderBy

Also using the Sort in place of OrderBy will ensure sorting the same memory, not creating a new list as done by OrderBy

Code copied from Mivaweb:

public class Player {
     public string Type { get; set; }
     public string Gender { get; set; }
     public int AmountOfPlayers { get; set; }
}

Then

List<Player> list = new List<Player>();
list.Add(new Player() { Type = "swim", Gender = "women", AmountOfPlayers = 3 });

My code:

public static readonly string[] Order = new string[4] {"swim","baseball","volleyball","soccer"};

public static int OrderOf(string str)
{
    int ix = Array.IndexOf(Order, str);
    if (ix == -1)
    {
        ix = int.MaxValue;
    }
    return ix;
}

Then sort it:

list.Sort((p, q) => OrderOf(p.Type).CompareTo(OrderOf(q.Type)));

the list.Sort() is "in place", so it changes directly the list. Note that if sports different from the one in the lsit are present, they will go in the first places of the ordered list.

The OrderOf uses the Array.IndexOf to find the index of a type of sport in the Order array. Unknown types of sport go last.

This is not any sort actually but still if you want to process this data you can use following approach which is not good approach though.

string[,] outArray = new string[sort.Length, 3];
        for (int i = 0; i < sort.Length; i++)
        {
            int pos = Array.IndexOf(players, sort[i]);
            outArray[i, 0] = players[pos];
            outArray[i, 1] = players[pos + 1];
            outArray[i, 2] = players[pos + 2];
        }

Use objects,collections and lambda / LINQ for efficient solution and I guess all of the above answers follow the better approach.