पूर्णांक [] int करने के लिए कन्वर्ट करने के लिए कैसे [,] - सी #

Question

मैं एक आयाम में एक पूर्णांक सरणी है:

var intArray=new[] { 1, 2, 3, 4, 5, 6 }; 

और मैं इसे इस तरह के रूप दो आयामों, को परिवर्तित करना चाहते हैं:

var intArray2D=new[,] { {1, 2}, {3, 4}, {5, 6} }; 

मैं इसे सी # के साथ कैसे प्राप्त करूं?

Answer 1

मेरा मानना ​​है कि आप दो पूर्णांकों प्रत्येक की एक सरणी में एक पूर्णांक सरणी विभाजित करना चाहते हैं: आप की कोशिश कर सकते विशेष रूप से Points को

int[] list = new int[] { 1, 2, 3, 4, 5, 6}; 
int[][] newlist = new int[list.Length/2][]; 
for (int i = 0, n = 0; i < list.Length; i += 2, n++) 
{ 
    newlist[n] = new[] { list[i], list[i + 1] }; 
} 

यह सौंपने के लिए:

List<Point> plist = new List<Point>(); 
for (int i = 0; i < list.Length; i += 2) 
{ 
    plist.Add(new Point(list[i], list[i + 1])); 
} 

Answer 2

एक पाश शायद साथ

:

for (int i = 0; i < oldArr.Length; i=i+2) 
{ 
    newArr[i/2, 0] = oldArr[i]; 
    newArr[i/2, 1] = oldArr[i + 1]; 
} 

untested है, लेकिन आप सही दिशा में इशारा किया मिलना चाहिए ...

Answer 3

आयामों के उत्पाद एक ही कर रहे हैं, सबसे तेज़ तरीका शायद होगा एक निश्चित कथन का उपयोग करके मैट्रिक्स को पिन करने के लिए, मार्शलिंग क्लास का उपयोग करने के लिए सरणी से निरंतर ब्लॉक को शून्य से बनाए गए इंटप्राटर पर कॉपी करने के लिए * आप निश्चित से प्राप्त हुए हैं।

आपको इसे असुरक्षित कथन में लपेटना होगा और असेंबली की बिल्ड कॉन्फ़िगरेशन में असुरक्षित सक्षम करना होगा।

Answer 4

आप इस कोशिश कर सकते:

int [] a = {1,2,3,4,5,6}; 
int [,] b = new int[a.Length/2,2]; 

for(int i = 0;i<a.Length;i++) 
{ 
    b[i/2,i%2] = a[i]; 
} 

ध्यान दें कि मैं/2 एक पूर्णांक प्रभाग है, इसलिए दोनों 4/2 और 5/2 2 जो टपल 5 के लिए 2Darray में एक सही सूचकांक है दे देंगे और मूल सरणी से 6। दूसरी अनुक्रमणिका को 2 से विभाजित होने पर अनुस्मारक का उपयोग करके निर्धारित किया जाता है, अगर यह सूचकांक भी संख्या है और 1 यदि मूल सरणी से आइटम की अनुक्रमणिका विषम संख्या है तो यह 0 देगी।

Answer 5

आप इसका उपयोग कर सकते कोड। यहां आप अपनी पसंद की कोई भी लंबाई भेज सकते हैं। आप arry []] arry []] को किसी भी lenth.2 या 3 के लिए "deivde" या आप कभी भी क्या पसंद कर सकते हैं! जब तक आकार% a.length == 0 !!!!

कोड

 static int[,] convert(int[] a, int size) 
    { 
     int[,] value = new int[a.Length/size, size]; 
     int counter = 0; 
     // 
     for (int b = 0; b < value.GetLength(0); b++) 
      for (int c = 0; c < value.GetLength(1); c++) 
      { 
       value[b, c] = a[counter]; 
        counter++; 
      } 
     return value; 
    } 

Answer 6

मैं सरणी के किसी भी आयाम के लिए ग #

int Size = OldArray.Length; 
int[,] NewPoints = null; 

if (Size % 2 != 0) { 
    //Error - Array has odd number of elements! 
} else { 
    for (i = 0; i <= Size - 1; i += 2) { 
    Array.Resize(ref AllPoints, (i/2) + 1, 2); 
    NewPoints[i/2, 0] = OldArray(i); 
    NewPoints[i/2, 1] = OldArray(i + 1); 
    } 
} 

Answer 7

मैं इस पर विचार करेंगे करने के लिए vb से परिवर्तित कर दिया है:

public class TestClass { 
    public static void TestMethod2D() { 
     var intLinear=new[] { 1, 2, 3, 4, 5, 6 }; 
     var indexer2D=new ArrayIndexer<int>(3, 2); 

     for(var i=intLinear.Length; i-->0; indexer2D[i]=intLinear[i]) 
      ; 

     var int2D=(int[,])indexer2D.ToArray(); 
    } 

    public static void TestMethod4D() { 
     var intLinear=new[] { 1, 2, 3, 4, 5, 6 }; 
     var indexer4D=new ArrayIndexer<int>(2, 2, 2, 2); 

     for(var i=intLinear.Length; i-->0; indexer4D[i]=intLinear[i]) 
      ; 

     var int4D=(int[, , ,])indexer4D.ToArray(); 
    } 
} 

public partial class ArrayIndexer<T> { 
    public Array ToArray() { 
     return m_Array; 
    } 

    public ArrayIndexer(params int[] lengths) { 
     m_Array=Array.CreateInstance(typeof(T), lengths); 
    } 

    public T this[params int[] indices] { 
     set { 
      m_Array.SetValue(value, indices.Transform(m_Array)); 
     } 

     get { 
      return (T)m_Array.GetValue(indices.Transform(m_Array)); 
     } 
    } 

    Array m_Array; 
} 

public static partial class ArrayExtensions { 
    public static int[] Transform(
     this int[] indices, Array array, bool isRowMajor=true) { 
     if(indices.Length>array.Rank) 
      return indices; 
     else { 
      var list=indices.ToList(); 

      if(isRowMajor) 
       list.Reverse(); 

      for(int r, q=0, i=0, count=array.Rank; count-->0; ++i) { 
       var index=isRowMajor?count-i:i; 

       if(indices.Length>i) { 
        q=Math.DivRem(indices[i]+q, array.GetLength(index), out r); 
        list[i]=r; 
       } 
       else { 
        if(index<0) { 
         list.Add(q); 
         q=0; 
        } 
        else { 
         q=Math.DivRem(q, array.GetLength(index), out r); 
         list.Add(r); 
        } 
       } 
      } 

      if(isRowMajor) 
       list.Reverse(); 

      return list.ToArray(); 
     } 
    } 
} 

ArrayExtensions.Transform एक सूचकांक ट्रांसफार्मर है, यह किसी दिए गए सरणी की ज्यामिति के साथ रैखिक परिवर्तन करता है। isRowMajor लेआउट को नियंत्रित करता है, जैसे कि आप x, y में या y, x क्रम में मानेंगे।

Answer 8

यदि एक आयामी सरणी में row major order में आदिम डेटा होता है, और 2 आयामी सरणी की कुल क्षमता एक आयामी सरणी की लंबाई के बराबर होती है, तो आप इसका उपयोग कर सकते हैं।

int[] source = new int[6]; 
int[,] target = new int[3, 2]; 
Buffer.BlockCopy(source, 0, target, 0, source.Length * sizeof(int)); 

ध्यान दें कि Array.Copy और अन्य सरणी/सूची तरीकों के विपरीत, Buffer.BlockCopyबाइट्स डेटा की के एक नंबर पर चल रही है, भले ही सरणी के प्रत्येक तत्व 1 बाइट से बड़ा है। यह केवल आदिम डेटा प्रकारों के सरणी पर भी काम करता है।

अतिरिक्त संदर्भ:

• बहुआयामी सरणियों पंक्ति-प्रमुख आदेश (ECMA-335 Partition I, §8.9.1)
• Buffer.BlockCopy

संपादित में जमा हो जाती: यहाँ एक पूर्ण इकाई परीक्षण है।

[TestMethod] 
public void SOTest() 
{ 
    int[] source = new int[6] { 1, 2, 3, 4, 5, 6 }; 
    int[,] destination = new int[3, 2]; 
    Buffer.BlockCopy(source, 0, destination, 0, source.Length * sizeof(int)); 
    Assert.AreEqual(destination[0, 0], 1); 
    Assert.AreEqual(destination[0, 1], 2); 
    Assert.AreEqual(destination[1, 0], 3); 
    Assert.AreEqual(destination[1, 1], 4); 
    Assert.AreEqual(destination[2, 0], 5); 
    Assert.AreEqual(destination[2, 1], 6); 
}