আমি কীভাবে সি # তে দুটি অ্যারে যুক্ত করতে পারি?


267
int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };

int[] z = // your answer here...

Debug.Assert(z.SequenceEqual(new int[] { 1, 2, 3, 4, 5 }));

এই মুহূর্তে আমি ব্যবহার করি

int[] z = x.Concat(y).ToArray();

কোন সহজ বা আরও কার্যকর পদ্ধতি আছে?


8
"দক্ষ" বলতে কী বোঝ? কোডটি যেমন হয় তেমনি সংক্ষিপ্ত, সুতরাং আমি ধরে নিই যে আপনি সিপিইউ / র‌্যামের ক্ষেত্রে দক্ষ বলতে চান?
টিটোনি

4
না, রিফ্লেক্টর সহ একটি তাত্ক্ষণিক দৃষ্টিভঙ্গি দেখায় যে এটি ডাবল-কখন-পূর্ণ বাফার ব্যবহার করে
এরিক্কালেন

কেবল পরিষ্কার হয়ে উঠুন আমার কাছে টাইপ ইন্ট [] এর এক ধরণের হতে হবে।
হাইভিচার্স 11:59

4
দক্ষতার বিষয়ে আমি আসলেই উদ্বিগ্ন নই। (আমি সহজ বা আরও দক্ষ বলেছি)) অন্যান্য সাধারণ লোকেরা কীভাবে এই সাধারণ কাজটি পরিচালনা করছে তা যাচাই করতে আমি প্রশ্নটি জিজ্ঞাসা করেছি।
hwiechers

উত্তর:


331
var z = new int[x.Length + y.Length];
x.CopyTo(z, 0);
y.CopyTo(z, x.Length);

8
@ ম্যানথ্রাক্স -> এর প্রতিরক্ষা ক্ষেত্রে সি # তালিকা তালিকার পক্ষে থাকে যা অ্যারের চেয়ে অনেক বেশি শক্তিশালী। মনে হচ্ছে অ্যারে ব্যবহারের একমাত্র কার্যকরী উদ্দেশ্য হ'ল আন্তঃআরপি কল (পরিচালনা না করা সি ++)।
লেভি ফুলার

@ লেভিফুলার আর একটি জায়গা যেখানে সি # অ্যারে ব্যবহার করে তা ভেরিয়েবল-সংখ্যা paramsপরামিতি সহ।
ChrisW

1
@ লেভিফুলার - এটি অদ্ভুত যে অনেক সিস্টেমের রুটিনগুলি তালিকার পরিবর্তে অ্যারে ফিরিয়ে দেয়। যেমন System.IO.Directory.GetFiles()স্ট্রিংগুলির একটি অ্যারের প্রদান করে।
অরিয়েন্ট ইলেজিল

4
এটি অদ্ভুত নয়। একটি অ্যারে অপরিবর্তনীয়, একটি তালিকা। এছাড়াও একটি তালিকা অ্যারের তুলনায় আরও মেমরি ব্যবহার করে, যদি না ট্রিমএক্সসেস না বলা হয় (যা টোলিস্টে ঘটে না)
সিএসপি ২

1
এছাড়াও ডেটা অ্যাক্সেস করার সময় অ্যারের তালিকার চেয়ে দ্রুত হয়, কারণ তালিকার ভিতরে অ্যারেটি কেবল আবৃত হয় এবং সূচককে কল করার জন্য ওভারহেড থাকে।
C0DEF52

84

এটা চেষ্টা কর:

List<int> list = new List<int>();
list.AddRange(x);
list.AddRange(y);
int[] z = list.ToArray();

5
বা এমনকিList<int> list = new List<int>(x);
ম্যাথু শার্লে

7
X. কনক্যাট (y) এর চেয়ে কীভাবে আরও দক্ষ? এটি কার্যকর এবং সব কিছু, আমি কেবল ভাবছি এমন কিছু আছে যা এটি আরও ভাল করে তোলে?
মাইক টু

7
আপনি প্রথম লাইন তালিকা তৈরি করতে চাইতে পারেন <int> list = new list <int> (x.Length + y.Length); পুনরায় আকারটি এড়ানোর জন্য আপনি অ্যাড্রেঞ্জ
মাইক টু

5
পছন্দ করুন প্রশ্নটি আরও কার্যকর সমাধানের জন্য জিজ্ঞাসা করছে। আমি জানি শিরোনামটি এটিকে শোনায় যে কোনও পুরানো সংমিশ্রণটি করবে তবে পুরো প্রশ্নটি এর বাইরে চলে যায়। কিছু উত্তর পড়ে আমার মনে হয় কিছু লোক শিরোনামের উত্তর দিচ্ছে। সুতরাং আমি ভেবেছিলাম যে এই উত্তরটি সম্ভবত দক্ষতার উল্লেখ করা উচিত যদি এটি উত্সগুলি প্রাপ্য হয় যেহেতু এটি প্রশ্নের মূল বিষয় বলে মনে হয়েছিল।
মাইক টু

2
দেখা যাচ্ছে যে অ্যাডরেঞ্জ আসলে বেশ ব্যয়বহুল প্রক্রিয়া, সুতরাং এই বোর্ডের প্রথম উত্তরটি পছন্দসই
লিয়াম

49

আপনি একটি এক্সটেনশন পদ্ধতি লিখতে পারেন:

public static T[] Concat<T>(this T[] x, T[] y)
{
    if (x == null) throw new ArgumentNullException("x");
    if (y == null) throw new ArgumentNullException("y");
    int oldLen = x.Length;
    Array.Resize<T>(ref x, x.Length + y.Length);
    Array.Copy(y, 0, x, oldLen, y.Length);
    return x;
}

তারপর:

int[] x = {1,2,3}, y = {4,5};
int[] z = x.Concat(y); // {1,2,3,4,5}

1
ইতিমধ্যে কি কোনও এক্সটেনশন পদ্ধতি নেই যা কোনও আইনুনিউরেবলের জন্য কাজ করে?
মাইক টু

2
হ্যাঁ, এবং আমি বেশিরভাগ ক্ষেত্রে এটি সুখে ব্যবহার করব। তবে তাদের প্রচুর ওভারহেড রয়েছে। এটা নির্ভর করে; ওভারহেডগুলি 98% সময় ঠিক আছে। আপনি যদি 2% এর মধ্যে থাকেন তবে কিছু প্রত্যক্ষ মেমকোপি / অ্যারের কাজ কার্যকর।
মার্ক গ্র্যাভেল

1
@ নওফাল, কীভাবে Copyদ্রুত CopyTo? বিশদ যত্ন?
skrebbel

1
@ এসক্রেবেল আমার একটি ভুল মন্তব্য ছিল। আমি তখন কিছু পরীক্ষা করেছি এবং কপিটি দ্রুত পেয়েছি। তবে এখন মনে হচ্ছে তারা ঠিক সমান। আমি তখন যা পেয়েছি তা হতে পারে যে সামগ্রিকভাবে মার্কের দৃষ্টিভঙ্গি আরও কার্যকরী যেহেতু তিনি একই উদাহরণটি পাস করছেন যখন জেডের পদ্ধতির সময় তিনি একটি নতুন অ্যারে তৈরি করছেন। ক্ষমা
প্রার্থনা

1
পছন্দ করেছেন এই পদ্ধতির ভিতরে এক্সটি কেবল একটি স্থানীয় ভেরিয়েবল, পুনরায় আকারের পদ্ধতিতে এক্সকে রেফারেন্স হিসাবে পাস করা একটি নতুন অ্যারে তৈরি করে এবং এর সাথে নির্দেশ করার জন্য (স্থানীয় ভেরিয়েবল) এক্সকে পরিবর্তন করতে পারে। বা পুনঃব্যবহার করতে: এক্স আকার পরিবর্তন করেছে এবং এক্সটেনশন পদ্ধতির অভ্যন্তরে এক্স একই পরিবর্তনশীল, তবে এক্স রেফারেন্স হিসাবে এক্সটেনশন পদ্ধতিতে প্রেরণ করা হয় না, সুতরাং এক্সটি এক্সটেনশানটি যে স্কোপ থেকে ডাকা হয়েছিল তার পরিবর্তকের চেয়ে পৃথক পরিবর্তনশীল is ।
আনোরজাকেন

40

আমি আরও সাধারণ-উদ্দেশ্য সমাধানে স্থির হয়েছি যা একই ধরণের এক-মাত্রিক অ্যারেগুলির একটি স্বেচ্ছাসেবী সেটকে সম্মতি দেয়। (আমি একসাথে 3+ সমালোচনা করছি))

আমার ফাংশন:

    public static T[] ConcatArrays<T>(params T[][] list)
    {
        var result = new T[list.Sum(a => a.Length)];
        int offset = 0;
        for (int x = 0; x < list.Length; x++)
        {
            list[x].CopyTo(result, offset);
            offset += list[x].Length;
        }
        return result;
    }

এবং ব্যবহার:

        int[] a = new int[] { 1, 2, 3 };
        int[] b = new int[] { 4, 5, 6 };
        int[] c = new int[] { 7, 8 };
        var y = ConcatArrays(a, b, c); //Results in int[] {1,2,3,4,5,6,7,8}

সুন্দর ফাংশন, ধন্যবাদ! এটিকে এক্সটেনশান করতে পরিবর্তন params T[][]করা this T[][]হয়েছে।
চিহ্নিত করুন

হাই ছেলেরা, এই ফাংশনটি দেখতে আমি যা খুঁজছিলাম তা দেখে মনে হচ্ছে তবে কীভাবে আমি এটি অর্জন করব? লিঙ্ক @ মার্ক
জর্জি বি

31

এই হল:

using System.Linq;

int[] array1 = { 1, 3, 5 };
int[] array2 = { 0, 2, 4 };

// Concatenate array1 and array2.
var result1 = array1.Concat(array2);

4
আপনার অর্থ int[] result = array1.ToList().Concat(array2.ToList()).toArray();আপনি সরাসরি অ্যারেতে কনক্যাট প্রয়োগ করতে পারবেন না আমি বিশ্বাস করি
মাইকেল মাইকেলাইলিস

4
এই সমাধানটি - z = x. কনক্যাট (y) - উপরের মূল প্রশ্নে উল্লেখ করা হয়েছে।
জন স্নাইডার

1
এটি হ'লtoArray() Cannot implicitly convert type 'System.Collections.Generic.IEnumerable<string>' to 'string[]'. An explicit conversion exists (are you missing a cast?)
টিবোর উদवारी

2
এটি সরাসরি উত্তর নয়। ওপি জিজ্ঞাসা করেছিল int[] result = ?, আপনি নিজের উত্তরের পিছনে আপনার উত্তরটির সমস্যাটি গোপন varকরছেন যাতে আপনার ফলাফল আসবে IEnumerable<int>, তা নয় int[]। ( varপদ্ধতিতে ফিরে আসার জন্য কেন আমি পছন্দ করি না তার একটি কারণ )
ডেভিড এস

2
এই পদ্ধতিটি প্রশ্নের মধ্যে যা ব্যবহৃত হয় তাই এই উত্তরটি কোনও নতুন তথ্য সরবরাহ করে না এবং .ToArray()কল ব্যতীত এই কোডটি একটি আসল অ্যারে ফিরিয়ে দেবে না সুতরাং এটিও একটি ভুল উত্তর।
মণি গন্ধম

10

আপনি ToArray () কলটি শেষ করতে পারেন। কনক্যাট কল করার পরে আপনার অ্যারে হওয়ার কোনও কারণ আছে?

কনক্যাট কল করা উভয় অ্যারেতে একটি পুনরুক্তি তৈরি করে। এটি কোনও নতুন অ্যারে তৈরি করে না তাই আপনি কোনও নতুন অ্যারের জন্য আরও মেমরি ব্যবহার করেন নি। আপনি যখন টোআররে কল করেন আপনি আসলে একটি নতুন অ্যারে তৈরি করেন এবং নতুন অ্যারের জন্য মেমরিটি গ্রহণ করেন।

সুতরাং আপনার যদি উভয়কেই সহজে পুনরাবৃত্তি করতে হয় তবে কেবল কনক্যাটকে কল করুন।


8

আমি জানি ওপি পারফরম্যান্স সম্পর্কে শুধুমাত্র মৃদু আগ্রহী ছিল। বৃহত্তর অ্যারেগুলি আলাদা ফলাফল পেতে পারে (@ কুরডিশটি দেখুন)। এবং এটি সাধারণত (@ jordan.pepeds) কিছু যায় আসে না। কিছুই কম নয়, আমি কৌতূহলী ছিলাম এবং তাই আমার মন হারিয়ে গেল (যেমন @ টাইগারশার্ক ব্যাখ্যা করছিলেন) .... আমি এর অর্থ হ'ল আমি আসল প্রশ্নের উপর ভিত্তি করে একটি সাধারণ পরীক্ষা লিখেছি .... এবং সমস্ত উত্তর ....

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace concat
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] x = new int [] { 1, 2, 3};
            int[] y = new int [] { 4, 5 };


            int itter = 50000;
            Console.WriteLine("test iterations: {0}", itter);

            DateTime startTest = DateTime.Now;
            for(int  i = 0; i < itter; i++)
            {
                int[] z;
                z = x.Concat(y).ToArray();
            }
            Console.WriteLine ("Concat Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks );

            startTest = DateTime.Now;
            for(int  i = 0; i < itter; i++)
            {
                var vz = new int[x.Length + y.Length];
                x.CopyTo(vz, 0);
                y.CopyTo(vz, x.Length);
            }
            Console.WriteLine ("CopyTo Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks );

            startTest = DateTime.Now;
            for(int  i = 0; i < itter; i++)
            {
                List<int> list = new List<int>();
                list.AddRange(x);
                list.AddRange(y);
                int[] z = list.ToArray();
            }
            Console.WriteLine("list.AddRange Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.Concat(x, y);
            }
            Console.WriteLine("Concat(x, y) Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.ConcatArrays(x, y);
            }
            Console.WriteLine("ConcatArrays Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.SSConcat(x, y);
            }
            Console.WriteLine("SSConcat Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int k = 0; k < itter; k++)
            {
                int[] three = new int[x.Length + y.Length];

                int idx = 0;

                for (int i = 0; i < x.Length; i++)
                    three[idx++] = x[i];
                for (int j = 0; j < y.Length; j++)
                    three[idx++] = y[j];
            }
            Console.WriteLine("Roll your own Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.ConcatArraysLinq(x, y);
            }
            Console.WriteLine("ConcatArraysLinq Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.ConcatArraysLambda(x, y);
            }
            Console.WriteLine("ConcatArraysLambda Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                List<int> targetList = new List<int>(x);
                targetList.Concat(y);
            }
            Console.WriteLine("targetList.Concat(y) Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] result = x.ToList().Concat(y.ToList()).ToArray();
            }
            Console.WriteLine("x.ToList().Concat(y.ToList()).ToArray() Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);
        }
    }
    static class Methods
    {
        public static T[] Concat<T>(this T[] x, T[] y)
        {
            if (x == null) throw new ArgumentNullException("x");
            if (y == null) throw new ArgumentNullException("y");
            int oldLen = x.Length;
            Array.Resize<T>(ref x, x.Length + y.Length);
            Array.Copy(y, 0, x, oldLen, y.Length);
            return x;
        }

        public static T[] ConcatArrays<T>(params T[][] list)
        {
            var result = new T[list.Sum(a => a.Length)];
            int offset = 0;
            for (int x = 0; x < list.Length; x++)
            {
                list[x].CopyTo(result, offset);
                offset += list[x].Length;
            }
            return result;
        }


        public static T[] SSConcat<T>(this T[] first, params T[][] arrays)
        {
            int length = first.Length;
            foreach (T[] array in arrays)
            {
                length += array.Length;
            }
            T[] result = new T[length];
            length = first.Length;
            Array.Copy(first, 0, result, 0, first.Length);
            foreach (T[] array in arrays)
            {
                Array.Copy(array, 0, result, length, array.Length);
                length += array.Length;
            }
            return result;
        }

        public static T[] ConcatArraysLinq<T>(params T[][] arrays)
        {
            return (from array in arrays
                    from arr in array
                    select arr).ToArray();
        }

        public static T[] ConcatArraysLambda<T>(params T[][] arrays)
        {
            return arrays.SelectMany(array => array.Select(arr => arr)).ToArray();
        }
    }

}

ফলাফল ছিল:

এখানে চিত্র বর্ণনা লিখুন

আপনার নিজের জয় রোল।


পদ্ধতিগুলি যে পদ্ধতিগুলিতে ব্যবহৃত হয়েছিল তার সাথে ন্যায়বিচারে, পদ্ধতিগুলি সম্ভবত আমার সিস্টেমে প্রায় 10,000 টি টিক যোগ করেছে।
জোড়া লাগানো

1
আমি আপনার কোডটি ভিজ্যুয়াল স্টুডিওতে 2013 রিলিজ মোডে CopyToচালিয়েছি এবং দেখতে পেয়েছি যে, যদি পরীক্ষিত অ্যারেটি আপনার মতো 1000 এর মতো ক্ষুদ্র না হয় তবে এর চেয়ে দ্রুততম এবং ~ 3x দ্রুত হবে Roll your own
মিঃ রিঃ

@ মিঃরি হ্যাঁ, আমার অ্যারেটি খুব ছোট ছিল না এটি। ধন্যবাদ। ব্লক অনুলিপি আরও ভাল করে কিনা তা দেখতে আগ্রহী ...
একত্রিত

7

Concatপদ্ধতিটি সম্পর্কে সতর্কতা অবলম্বন করুন । সি # তে অ্যারে কনটেনটেশন পোস্টটি ব্যাখ্যা করে যে:

var z = x.Concat(y).ToArray();

বড় অ্যারেগুলির জন্য অকার্যকর হবে। এর অর্থ হল Concatপদ্ধতিটি কেবলমাত্র মাঝারি আকারের অ্যারেগুলির জন্য (10000 উপাদান পর্যন্ত)।


2
10,000 টিরও বেশি উপাদান থাকা অ্যারে দিয়ে কী করা উচিত?
অ্যালেক্স

6
public static T[] Concat<T>(this T[] first, params T[][] arrays)
{
    int length = first.Length;
    foreach (T[] array in arrays)
    {
        length += array.Length;
    }
    T[] result = new T[length];
    length = first.Length;
    Array.Copy(first, 0, result, 0, first.Length);
    foreach (T[] array in arrays)
    {
        Array.Copy(array, 0, result, length, array.Length);
        length += array.Length;
    }
    return result;
}

2
স্ট্যাকওভারফ্লোতে দয়া করে কেবল কোডটি পেস্ট করবেন না, তবে আপনার পদ্ধতির ব্যাখ্যাও করুন। এই নির্দিষ্ট ক্ষেত্রে আপনার দেরী উত্তর ইতিমধ্যে প্রদত্ত (এবং স্বীকৃত) উত্তরগুলিতে কী যুক্ত করে তাও আপনাকে ব্যাখ্যা করতে পারে
জার্ট আর্নল্ড

1
প্রথম পরমের আগে "এই" কী করছে তা নিশ্চিত নন, তবে বাকীগুলির জন্য এটি একটি দুর্দান্ত ফাংশন। জেনেরিক, এবং অসীম পরিমাণে পরামিতি।
নাইয়ারগডস

2
হাই নায়ারগডস আপনার প্রশ্নের উত্তর দেওয়ার জন্য, "এই" কীওয়ার্ডটি ফাংশনটিকে একটি এক্সটেনশন পদ্ধতিতে ব্যবহৃত হয়। এক্সটেনশন পদ্ধতির বিষয়ে আরও তথ্যের জন্য এই এমএসডিএন নিবন্ধটি দেখুন
জেফিশ 222

6

আরও দক্ষ (অপেক্ষাকৃত দ্রুত) ব্যবহার করতে Buffer.BlockCopyবেশি Array.CopyTo,

int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };

int[] z = new int[x.Length + y.Length];
var byteIndex = x.Length * sizeof(int);
Buffer.BlockCopy(x, 0, z, 0, byteIndex);
Buffer.BlockCopy(y, 0, z, byteIndex, y.Length * sizeof(int));

আমি একটি সহজ পরীক্ষা প্রোগ্রাম লিখেছিলাম যা "জিটার আপ ওয়ার্মস আপ", মুক্তির মোডে সংকলন করে এবং এটি আমার মেশিনে কোনও ডিবাগার সংযুক্ত না করে চালিয়েছিল।

প্রশ্নের 10,000,000 পুনরাবৃত্তি উদাহরণের জন্য

কনক্যাট 3088 মিমি নিয়েছে

কপিরটো 1079ms নিয়েছিল

ব্লককপি 603ms নিয়েছে

আমি যদি পরীক্ষার অ্যারেগুলিকে 0 থেকে 99 এর মধ্যে দুটি অনুক্রমগুলিতে পরিবর্তন করি তবে আমি এর মতো ফলাফল পাব,

কনক্যাট 45945 মিমি নিয়েছে

কপিরটো 2230 মিমি নিয়েছে

ব্লককপি 1689ms নিয়েছে

এই ফলাফলগুলি থেকে আমি দৃsert়ভাবে বলতে পারি যে পদ্ধতিগুলি CopyToএবং BlockCopyপদ্ধতিগুলি তুলনায় উল্লেখযোগ্যভাবে আরও দক্ষ Concatএবং তদ্ব্যতীত, যদি পারফরম্যান্স একটি লক্ষ্য হয় তবে BlockCopyএর মূল্যও শেষ হবে CopyTo

এই উত্তরটি সরবরাহ করার জন্য, যদি পারফরম্যান্সে কোনও গুরুত্ব আসে না, বা খুব কম পুনরাবৃত্তি হবে সেই পদ্ধতিটি বেছে নিন যা আপনার পক্ষে সবচেয়ে সহজ। Buffer.BlockCopyএই প্রশ্নের ক্ষেত্রের বাইরে ধরণের রূপান্তরকরণের জন্য কিছু উপযোগিতা সরবরাহ করে।


6

বিলম্বিত উত্তর :-).

public static class ArrayExtention
    {

        public static T[] Concatenate<T>(this T[] array1, T[] array2)
        {
            T[] result = new T[array1.Length + array2.Length];
            array1.CopyTo(result, 0);
            array2.CopyTo(result, array1.Length);
            return result;
        }

    }

3

সম্মিলিত অ্যারে ধরে রাখার জন্য র‌্যামের (এবং সিপিইউ) দিক থেকে সর্বাধিক দক্ষ কাঠামো হ'ল একটি বিশেষ শ্রেণি যা আইয়ুনামেবল প্রয়োগ করে (বা আপনি যদি অ্যারে থেকে প্রাপ্তও চান) এবং মানগুলি পড়তে অভ্যন্তরীণভাবে মূল অ্যারেগুলিতে লিঙ্ক করে। আফাইক কনক্যাট ঠিক তাই করে।

আপনার নমুনা কোডে আপনি .ToArray () কে বাদ দিতে পারেন, যা এটি আরও কার্যকর করে তুলবে।


3

পুরানো থ্রেডটি পুনরুদ্ধার করতে দুঃখিত, তবে এটি সম্পর্কে কীভাবে:

static IEnumerable<T> Merge<T>(params T[][] arrays)
{
    var merged = arrays.SelectMany(arr => arr);

    foreach (var t in merged)
        yield return t;
}

তারপরে আপনার কোডে:

int[] x={1, 2, 3};
int[] y={4, 5, 6};

var z=Merge(x, y);  // 'z' is IEnumerable<T>

var za=z.ToArray(); // 'za' is int[]

যতক্ষণ না আপনি কল করেন .ToArray(), .ToList()বা .ToDictionary(...), মেমরিটি বরাদ্দ না করা হয় আপনি "আপনার ক্যোয়ারীটি তৈরি করতে" এবং এটি কার্যকর করার জন্য এই তিনজনের মধ্যে একজনকে কল করতে পারেন বা ক্লজটি ব্যবহার করে foreach (var i in z){...}যা কেবল একবারে কোনও আইটেম ফেরত দেয়yield return t; উপরে ...

উপরের ফাংশনটি নিম্নরূপে একটি এক্সটেনশন হিসাবে তৈরি করা যেতে পারে:

static IEnumerable<T> Merge<T>(this T[] array1, T[] array2)
{
    var merged = array1.Concat(array2);

    foreach (var t in merged)
        yield return t;
}

কোডে, আপনি যেমন কিছু করতে পারেন:

int[] x1={1, 2, 3};
int[] x2={4, 5, 6};
int[] x3={7, 8};

var z=x1.Merge(x2).Merge(x3);   // 'z' is IEnumerable<T>

var za=z.ToArray(); // 'za' is int[]

বাকিটা আগের মতোই।

এর অন্য একটি উন্নতিতে পরিবর্তিত T[]হবে IEnumerable<T>(তাই params T[][]হয়ে যাবেparams IEnumerable<T>[]এই ক্রিয়াকলাপকে কেবল অ্যারে থেকে বেশি গ্রহণ করার জন্য )

আশাকরি এটা সাহায্য করবে.


2

আপনি যেভাবে উল্লেখ করেছেন সেভাবে আপনি এটি করতে পারেন বা আপনি যদি এটি সম্পর্কে সত্যই ম্যানুয়াল পেতে চান তবে আপনি নিজের লুপটি রোল করতে পারেন:

        string[] one = new string[] { "a", "b" };
        string[] two = new string[] { "c", "d" };
        string[] three;

        three = new string[one.Length + two.Length];

        int idx = 0;

        for (int i = 0; i < one.Length; i++)
            three[idx++] = one[i];
        for (int j = 0; j < two.Length; j++)
            three[idx++] = two[j];

@ নওফাল আমি মনে করি এটি অ্যারের আকারের উপর নির্ভর করবে। এটি আমার ছোট অ্যারে আকারের পরীক্ষা জিতেছে।
জোড়া লাগানো

2

আমি লিনকিউ বা ল্যাম্বডা এক্সপ্রেশন ব্যবহার করে একটি মার্জিত ওয়ান লাইন সমাধান পেয়েছি , উভয়ই একই কাজ করে (প্রোগ্রাম সংকলিত হওয়ার পরে লিনক্যা ল্যাম্বডায় রূপান্তরিত হয়)। সমাধানটি কোনও অ্যারের ধরণের এবং অ্যারে সংখ্যার জন্য কাজ করে।

লিনকিউ ব্যবহার:

public static T[] ConcatArraysLinq<T>(params T[][] arrays)
{
    return (from array in arrays
            from arr in array
            select arr).ToArray();
}

ল্যাম্বদা ব্যবহার:

public static T[] ConcatArraysLambda<T>(params T[][] arrays)
{
    return arrays.SelectMany(array => array.Select(arr => arr)).ToArray();
}

আমি নিজের পছন্দকে উভয়ই সরবরাহ করেছি। পারফরমেন্স জ্ঞানী @Sergey Shteyn এর বা @ deepee1 এর সমাধান একটু দ্রুত, ল্যামডা অভিব্যক্তি ধীরতম হচ্ছে। নেওয়া সময়টি অ্যারের উপাদানগুলির ধরণের (গুলি) এর উপর নির্ভরশীল, তবে লক্ষ লক্ষ কল না থাকলে পদ্ধতির মধ্যে উল্লেখযোগ্য পার্থক্য নেই।


1

আপনাকে যা মনে রাখতে হবে তা হ'ল লিনকিউ ব্যবহার করার সময় আপনি বিলম্বিত কার্যকর হওয়া ব্যবহার করছেন। এখানে বর্ণিত অন্যান্য পদ্ধতিগুলি নিখুঁতভাবে কাজ করে তবে এগুলি অবিলম্বে কার্যকর করা হয়। তদুপরি কনক্যাট () ফাংশনটি সম্ভবত আপনি নিজেরাই করতে পারবেন না এমন উপায়ে অনুকূলিত হয়েছে (অভ্যন্তরীণ এপিআই, ওএস কল ইত্যাদিতে কল)। যাইহোক, যদি না আপনার সত্যিকার চেষ্টা এবং অপ্টিমাইজ করার প্রয়োজন হয়, আপনি বর্তমানে "সমস্ত মন্দের মূল" এর পথে রয়েছেন;)


1

নিম্নলিখিত চেষ্টা করুন:

T[] r1 = new T[size1];
T[] r2 = new T[size2];

List<T> targetList = new List<T>(r1);
targetList.Concat(r2);
T[] targetArray = targetList.ToArray();

1

আমার উত্তর এখানে:

int[] z = new List<string>()
    .Concat(a)
    .Concat(b)
    .Concat(c)
    .ToArray();

এই পদ্ধতিটি সূচনা স্তরে ব্যবহার করা যেতে পারে, উদাহরণস্বরূপ স্ট্যাটিক অ্যারেগুলির স্থিতিশীল সংক্ষেপণ সংজ্ঞা দেওয়ার জন্য:

public static int[] a = new int [] { 1, 2, 3, 4, 5 };
public static int[] b = new int [] { 6, 7, 8 };
public static int[] c = new int [] { 9, 10 };

public static int[] z = new List<string>()
    .Concat(a)
    .Concat(b)
    .Concat(c)
    .ToArray();

যাইহোক, এটি দুটি বিবেচ্য বিষয় নিয়ে আসে যা আপনাকে বিবেচনা করা উচিত:

  • Concat পদ্ধতি উভয় অ্যারে উপর কোনো ইটারেটরে তৈরি করে: এটি একটি নতুন অ্যারে তৈরি করে না, এইভাবে পদ ধরে থাকা মানায় দক্ষ হচ্ছে ব্যবহৃত: তবে পরবর্তী ToArray  যেহেতু এটি আসলে একটি নতুন অ্যারে নির্মাণ এবং জন্য মেমরি আপ নিতে হবে যেমন সুবিধা অস্বীকার করবে নতুন অ্যারে
  • @ জোডরেল যেমন বলেছিলেন, Concatবড় অ্যারেগুলির জন্য বরং অদক্ষ হতে পারে: এটি কেবল মাঝারি আকারের অ্যারেগুলির জন্য ব্যবহার করা উচিত।

যদি পারফরম্যান্সের লক্ষ্যে লক্ষ্য করা আবশ্যক হয় তবে নিম্নলিখিত পদ্ধতিটি পরিবর্তে ব্যবহার করা যেতে পারে:

/// <summary>
/// Concatenates two or more arrays into a single one.
/// </summary>
public static T[] Concat<T>(params T[][] arrays)
{
    // return (from array in arrays from arr in array select arr).ToArray();

    var result = new T[arrays.Sum(a => a.Length)];
    int offset = 0;
    for (int x = 0; x < arrays.Length; x++)
    {
        arrays[x].CopyTo(result, offset);
        offset += arrays[x].Length;
    }
    return result;
}

বা (ওয়ান-লাইনার অনুরাগীদের জন্য):

int[] z = (from arrays in new[] { a, b, c } from arr in arrays select arr).ToArray();

যদিও পরবর্তী পদ্ধতিটি আরও মার্জিত, তবে পূর্বেরটি অবশ্যই পারফরম্যান্সের জন্য ভাল।

অতিরিক্ত তথ্যের জন্য, আমার ব্লগে এই পোস্টটি দেখুন


0

অন্তঃকরণের জন্য [] আপনি যা করেছেন তা আমার কাছে ভাল দেখাচ্ছে। অপরিচিতর উত্তরটিও ভাল কাজ করবে List<int>


2
কনক্যাট লিস্ট <int> এর জন্যও কাজ করবে। কনক্যাট সম্পর্কে এটিই দুর্দান্ত, এটি যে কোনও আইওনামেবল <>>
মাইক টু

0

ছোট অ্যারে <10000 উপাদানগুলির জন্য:

using System.Linq;

int firstArray = {5,4,2};
int secondArray = {3,2,1};

int[] result = firstArray.ToList().Concat(secondArray.ToList()).toArray();

লিঙ্ক ব্যবহার করবেন না কেন?
ইনা

0
static class Extensions
{
    public static T[] Concat<T>(this T[] array1, params T[] array2) => ConcatArray(array1, array2);

    public static T[] ConcatArray<T>(params T[][] arrays)
    {
        int l, i;

        for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++);

        var a = new T[l];

        for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++)
            arrays[i].CopyTo(a, l);

        return a;
    }
}

আমি মনে করি উপরের সমাধানটি আমি এখানে অন্যদের চেয়ে সাধারণ ও হালকা is এটি আরও সাধারণ কারণ এটি কেবল দুটি অ্যারের জন্য সংমিশ্রণ সীমাবদ্ধ করে না এবং হালকা হয় কারণ এটি লিনকুই বা তালিকা ব্যবহার করে না।

দ্রষ্টব্য দ্রষ্টব্য এবং যুক্ত সাধারণতা উল্লেখযোগ্য রানটাইম ওভারহেড যুক্ত করে না Note


আমি নতুন প্রশ্নগুলি অনুসন্ধান করার চেষ্টা করার পরামর্শ দিচ্ছি বা ইতিমধ্যে আপনার মতো বেশ কয়েকটি উত্তর রয়েছে - এর টুপি ইতিমধ্যে নেই।
অ্যান্ড্রু বারবার

আমি এই সমাধানটির প্রস্তাব দিয়েছিলাম কারণ আমি মনে করি এটি অন্যদের থেকে কী ভাল তা সংক্ষিপ্ত করে। এটি কারুকাজ করা হয়েছিল।
শ্রোয়া

-2

int [] x = new int [] {1, 2, 3}; int [] y = new int [] {4, 5};

int [] z = x.Union (y) .ToArray ();


2
Unionএটি করার খুব ভাল উপায় নয় কারণ এটি স্পষ্টভাবে কল করে Distinctএবং যোগদান করা সংগ্রহ থেকে কোনও নকলকে সরিয়ে দেয়। Concatঅনেক ভাল, তবে এটি ইতিমধ্যে মূল প্রশ্নে।
নুরচি

-2
int[] scores = { 100, 90, 90, 80, 75, 60 };
int[] alice = { 50, 65, 77, 90, 102 };
int[] scoreBoard = new int[scores.Length + alice.Length];

int j = 0;
for (int i=0;i<(scores.Length+alice.Length);i++)  // to combine two arrays
{
    if(i<scores.Length)
    {
        scoreBoard[i] = scores[i];
    }
    else
    {
        scoreBoard[i] = alice[j];
        j = j + 1;

    }
}


for (int l = 0; l < (scores.Length + alice.Length); l++)
{
    Console.WriteLine(scoreBoard[l]);
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.