C# La Divisione Di Una Matrice

Ho bisogno di dividere un array di indeterminato dimensioni, a metà, in due array separati.

L’array generato da una lista di stringhe utilizzando 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);
    }
}

}

  • Non c’è davvero alcuna cosa come un array di indeterminato dimensioni. Se è una matrice, ha una Lunghezza di proprietà.
  • la dimensione della matrice è determinato in base al numero di variabili di input da parte dell’utente. Mi sono fatto spiegare in alto.
  • possibile duplicato di Dividere una collezione in n parti con LINQ?

 

9 Replies
  1. 52

    È possibile utilizzare il seguente metodo per dividere un array in 2 array separati

    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);
    }
    • Grazie! Il secondo è perfetto!
    • +1 per l’utilizzo di metodi di estensione.
    • Non sono questi i metodi di estensione…
    • Questo utilizza Linq sequenza di metodi. Aggiungere il “utilizzo del Sistema.Linq” dichiarazione dello spazio dei nomi.
  2. 10

    Utilizzare un generico metodo split:

    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);
    }
  3. 6

    Voglio anche aggiungere una soluzione per dividere un array in diversi piccoli array che contiene un determinato numero di cellule.

    Un buon modo sarebbe quello di creare un generico metodo di estensione di dividere qualsiasi matrice. Questa è la mia:

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

    Inoltre, questa soluzione è differita. Quindi, è sufficiente chiamare split(size) sul tuo array.

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

    Divertirsi 🙂

  4. 6

    Ho avuto un problema con Linq Skip() e) funzioni quando ha a che fare con gli array con enormi quantità di elementi (es. matrici di byte), dove l’elemento conti sono a milioni.

    Questo approccio drasticamente ridotto split eseguire per me.

    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;
    }
    • Questo è il modo migliore per dividere lista separata.
  5. 1

    Se non si dispone di Linq, è possibile utilizzare la Matrice.Copia:

    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);
    }
  6. 0

    Perché stai passando il UList come ref? Non sembra essere un bisogno.

    Vorrei utilizzare un generico Split metodo se avevo bisogno di fare questo:

    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);
    }
    • Che ero solo io a giocare con il codice, è un remenant di alcune cose precedenti che erano lì.
  7. 0

    Penso che ciò che si sta cercando è il Array classe, in particolare il Array.Copy metodo statico. Si può pensare che la classe che contiene i metodi che sarebbero i metodi di istanza di matrici se C# matrici aveva metodi.

  8. 0

    Perché non si assegnano due array e copiare il contenuto ?

    EDIT: qui si va:

            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);
  9. 0

    Se paradigma funzionale è un problema, questo potrebbe aiutare:

       public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> seq, Int32 sizeSplits) {
         Int32 numSplits = (seq.Count() / sizeSplits) + 1;
         foreach ( Int32 ns in Enumerable.Range(start: 1, count: numSplits) ) {
            (Int32 start, Int32 end) = GetIndexes(ns);
            yield return seq.Where((_, i) => (start <= i && i <= end));
         }
    
         (Int32 start, Int32 end) GetIndexes(Int32 numSplit) {
            Int32 indBase1 = numSplit * sizeSplits;
            Int32 start = indBase1 - sizeSplits;
            Int32 end = indBase1 - 1;
            return (start, end);
         }
      }

Lascia un commento