web-dev-qa-db-fra.com

C # Division d'un tableau

Je dois diviser un tableau de taille indéterminée, au milieu, en deux tableaux distincts.

Le tableau est généré à partir d'une liste de chaînes à l'aide de ToArray ().

        public void AddToList ()
        {
            bool loop = true;
            string a = "";

            Console.WriteLine("Enter a string value and press enter to add it to the list");
            while (loop == true)
            {
                a = Console.ReadLine();

                if (a != "")
                {
                    mylist.Add(a);
                }
                else
                {
                    loop = false;
                }
            }

        }

        public void ReturnList()
        {
            string x = "";
            foreach (string number in mylist)
            {
                x = x + number + " ";
            }
            Console.WriteLine(x);
            Console.ReadLine();
        }

    }

    class SplitList
    {
        public string[] sTop;
        public string[] sBottom;

        public void Split(ref UList list)  
        {
            string[] s = list.mylist.ToArray();

            //split the array into top and bottom halfs

        }
    }

    static void Main(string[] args)
    {
        UList list = new UList();
        SplitList split = new SplitList();

        list.AddToList();
        list.ReturnList();

        split.Split(ref list);
    }
}

}

c#arrays
16
TheValheruGod

Vous pouvez utiliser la méthode suivante pour diviser un tableau en 2 tableaux distincts.

public void Split<T>(T[] array, int index, out T[] first, out T[] second) {
  first = array.Take(index).ToArray();
  second = array.Skip(index).ToArray();
}

public void SplitMidPoint<T>(T[] array, out T[] first, out T[] second) {
  Split(array, array.Length / 2, out first, out second);
}
43
JaredPar

Utilisez une méthode de scission générique:

public static void Split<T>(T[] source, int index, out T[] first, out T last)
{
    int len2 = source.Length - index;
    first = new T[index];
    last = new T[len2];
    Array.Copy(source, 0, first, 0, index);
    Array.Copy(source, index, last, 0, len2);
}
9
Cecil Has a Name

J'ai eu un problème avec les fonctions Skip () et Take () de Linq lorsqu'il s'agissait de tableaux avec des quantités massives d'éléments (c'est-à-dire des tableaux d'octets), où le nombre d'éléments est en millions.

Cette approche a considérablement réduit les temps d’exécution divisés pour moi.

public static IEnumerable<IEnumerable<T>> Split<T>(this ICollection<T> self, int chunkSize)
{
    var splitList = new List<List<T>>();
    var chunkCount = (int)Math.Ceiling((double)self.Count / (double)chunkSize);

    for(int c = 0; c < chunkCount; c++)
    {
        var skip = c * chunkSize;
        var take = skip + chunkSize;
        var chunk = new List<T>(chunkSize);

        for(int e = skip; e < take && e < self.Count; e++)
        {
            chunk.Add(self.ElementAt(e));
        }

        splitList.Add(chunk);
    }

    return splitList;
}
5
Jack

Je souhaite également ajouter une solution pour diviser un tableau en plusieurs tableaux plus petits contenant un nombre déterminé de cellules.

Une bonne façon serait de créer une méthode générique/extension pour scinder n'importe quel tableau. C'est à moi:

/// <summary>
/// Splits an array into several smaller arrays.
/// </summary>
/// <typeparam name="T">The type of the array.</typeparam>
/// <param name="array">The array to split.</param>
/// <param name="size">The size of the smaller arrays.</param>
/// <returns>An array containing smaller arrays.</returns>
public static IEnumerable<IEnumerable<T>> Split<T>(this T[] array, int size)
{
    for (var i = 0; i < (float)array.Length / size; i++)
    {
        yield return array.Skip(i * size).Take(size);
    }
}

De plus, cette solution est différée. Ensuite, appelez simplement split(size) sur votre tableau.

var array = new byte[] {10, 20, 30, 40, 50};
var splitArray = array.Split(2);

S'amuser :)

5
ZenLulz

Si vous n'avez pas Linq, vous pouvez utiliser Array.Copy:

public void Split(ref UList list)
{
    string[] s = list.mylist.ToArray();

    //split the array into top and bottom halfs
    string[] top = new string[s.Length / 2];
    string[] bottom = new string[s.Length - s.Length / 2];
    Array.Copy(s, top, top.Length);
    Array.Copy(s, top.Length, bottom, 0, bottom.Length);

    Console.WriteLine("Top: ");
    foreach (string item in top) Console.WriteLine(item);
    Console.WriteLine("Bottom: ");
    foreach (string item in bottom) Console.WriteLine(item);
}
1
Mark Byers

Pourquoi n'allouez-vous pas deux tableaux et ne copiez-vous pas le contenu?

EDIT: ici vous allez:

        String[] Origin = new String[4];
        Origin[0] = "zero";
        Origin[1] = "one";
        Origin[2] = "two";
        Origin[3] = "three";

        Int32 topSize = Origin.Length / 2;
        Int32 bottomSize = Origin.Length - topSize;
        String[] sTop = new String[topSize];
        String[] sBottom = new String[bottomSize];
        Array.Copy(Origin, sTop, topSize);
        Array.Copy(Origin, topSize , sBottom, 0, bottomSize);
0
BlueTrin

Pourquoi passez-vous la UList en tant que réf? Cela ne semble pas être nécessaire.

J'utiliserais une méthode Split générique si je devais le faire:

public void Split<T>(T[] array, out T[] left, out T[] right)
{
    left = new T[array.Length / 2];
    right = new T[array.Length - left.Length];

    Array.Copy(array, left, left.Length);
    Array.Copy(array, left.Length, right, 0, right.Length);
}
0
Adam Robinson

Je pense que vous recherchez la classe Array, en particulier la méthode statique Array.Copy. Vous pouvez penser que cette classe contient les méthodes qui seraient des méthodes d'instance de tableaux si les tableaux C # avaient des méthodes.

0
Nate C-K