R में Arrays

Array एक डेटा संरचना है जो बहु-आयामी डेटा रख सकती है। R में, array ऐसे ऑब्जेक्ट होते हैं जो दो या उससे अधिक आयामों वाला डेटा रख सकते हैं। उदाहरण के लिए, वर्गाकार मैट्रिस में दो पंक्तियाँ और दो स्तंभ हो सकते हैं और आयाम पाँच तक हो सकता है। Arrays केवल समान प्रकार के डेटा मानों को संग्रहीत कर सकते हैं। डेटा एक से अधिक आयामी हो सकता है, जहाँ पंक्तियाँ और स्तंभ होते हैं और किसी लंबाई के आयाम होते हैं।

Array का निर्माण

array() फ़ंक्शन एक array बनाता है, जो एक वेक्टर (संख्याएँ) और आर्गुमेंट में दिए गए dimension ('dim') को लेता है।

नीचे एक उदाहरण देखते हैं जहाँ 'array1' और 'array2' नाम के दो वेक्टर बनाए गए हैं।

vector1 =  c (5, 10, 15,20)
vector2 =  c (25, 30, 35, 40, 45, 50,55,60)

आप ऊपर के दो वेक्टरों को एक array के इनपुट के रूप में ले सकते हैं जहाँ dimension 4 * 4 माना गया है, और दो मैट्रिस या आयामी डेटा बनाए जाते हैं।

final = array (c (array1, array2),dim =c(4,4,3))
print (final)

उपरोक्त कोड का आउटपुट नीचे है:

, , 1

     [,1] [,2] [,3] [,4]
[1,]    5   25   45    5
[2,]   10   30   50   10
[3,]   15   35   55   15
[4,]   20   40   60   20

, , 2

     [,1] [,2] [,3] [,4]
[1,]   25   45    5   25
[2,]   30   50   10   30
[3,]   35   55   15   35
[4,]   40   60   20   40

, , 3

     [,1] [,2] [,3] [,4]
[1,]   45    5   25   45
[2,]   50   10   30   50
[3,]   55   15   35   55
[4,]   60   20   40   60

आइए हमारे array का नाम "Arr1" और "Arr2" को "matrix.names" का उपयोग करके बदलें। साथ ही, पंक्तियों के नाम ("row1","row2") और स्तंभों के नाम ("column1","column2","column3") क्रमशः कर दिए जाएँगे। मैट्रिस का आयाम 2 पंक्तियाँ और 3 स्तंभ है।

array1 =  c (9 , 18 )
array2 = c (27,36)
r.names = c ("column1","column2","column3")
c.names = c ("row1","row2")
m.names = c ("Arr1", "Arr2")

final = array (c (array1,array2), dim=c (2,3,2), dimnames=list (c.names, r.names, m.names))
print(final)

उपरोक्त कोड का आउटपुट नीचे है, जहाँ दो पंक्तियाँ और तीन स्तंभ हैं। साथ ही, जब किसी स्तंभ के मान समाप्त हो जाते हैं तो वे दोहराए जाते हैं:

, , Arr1

     column1 column2 column3
row1       9      27       9
row2      18      36      18

, , Arr2

     column1 column2 column3
row1      27       9      27
row2      36      18      36

Array में Indexing

एक array में बहु-आयामी तरीके से तत्व होते हैं जहाँ प्रत्येक तत्व तक किसी ऑपरेशन के लिए पहुँचा जा सकता है। तत्वों को '[]' का उपयोग करके इंडेक्स किया जा सकता है, जहाँ array-जैसी मैट्रिस में पंक्तियाँ और स्तंभ होते हैं, जिन्हें इस प्रकार इंडेक्स किया जा सकता है: mat[row, column]

आइए नीचे एक उदाहरण लेते हैं जहाँ array में 1 से 9 तक का वेक्टर इनपुट है। केवल तीन पंक्तियाँ और तीन स्तंभ हैं जहाँ 1 से 9 तक के मान शामिल हैं। 'c.names)' नया स्तंभ नाम है जिसमें वेक्टर ('c1', 'c2', 'c3') हैं और 'r.names' नया पंक्ति नाम है ('r1', 'r2', 'r3') जो भी एक वेक्टर है।

a1=  c (1,2,3,4)
a2= c (5,6,7,8,9)
r.names = c ("c1","c2","c3")
c.names = c ("r1","r2","r3")
m.names = c ("first")

arr = array (c (a1,a2), dim=c (3,3,1), dimnames=list (c.names, r.names, m.names))
print(arr)

, , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9

उपरोक्त कोड का आउटपुट नीचे है:

 , , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9 

आप देख सकते हैं कि 1 से 9 तक की मैट्रिस 3 3 आयाम (पंक्ति स्तंभ) रूप में जनरेट हुई हैं, और पंक्तियों व स्तंभों के नाम बदल दिए गए हैं।

आइए देखें कि निम्न उदाहरणों से array के तत्व कैसे निकाले जा सकते हैं।

1. आइए ऊपर दिए गए array 'arr' से संख्या '7' निकालें।

arr[1,3,1]

7

उपरोक्त कोड का आउटपुट 7 है। 'arr[1,3,1]' के अंदर पंक्ति 1, स्तंभ 3, और 1 पहले array 'arr' को दर्शाता है जिससे मान निकाला गया है।

1. 1 तक पहुँचने के लिए, 'arr[1,1,1]' में पंक्ति 1, स्तंभ 1, और 1 पहले array 'arr' को दर्शाता है जिससे मान निकाला गया है।

arr[1,1,1]

1

उपरोक्त कोड का आउटपुट 1 है।

1. एक साथ कई मानों तक पहुँचने के लिए, आपको इच्छित रेंज निर्दिष्ट करनी होगी।

arr[1:2,1:2,1]

उपरोक्त कोड नीचे जैसा आउटपुट देता है जहाँ 2 पंक्तियाँ, 2 स्तंभ होते हैं और 1 पहले array 'arr' को दर्शाता है जिससे मान निकाला गया है:

    c1    c2
r1    1    4
r2    2    5 

1. आप पूरे array 'arr' तक निम्न सिंटैक्स से पहुँच सकते हैं जहाँ 'arr[ , ,1]' सभी पंक्तियाँ और स्तंभ शामिल करने को निर्दिष्ट करता है, जिन्हें कॉमा द्वारा अलग किया गया है और स्पेस से दर्शाया गया है। यहाँ 1 उस array 'arr' को दर्शाता है जिसे निकाला जाना है।

arr[ , ,1]

उपरोक्त कोड नीचे जैसा आउटपुट देता है जहाँ सभी तत्व मौजूद हैं:

    c1    c2    c3
r1    1    4    7
r2    2    5    8
r3    3    6    9 

1. आप पूरा दूसरा पंक्ति निम्न कोड से प्राप्त कर सकते हैं जहाँ arr[2, ,1] दूसरी पंक्ति देता है, और 1 उस 'arr' को दर्शाता है जिसे निकाला जाना है।

arr[2,,1]

c1

2

c2

5

c3

8

उपरोक्त कोड नीचे जैसा आउटपुट देता है और c1, c2, c3 भी प्रिंट करता है।

c1 2
c2 5
c3 8

1. आप पूरा दूसरा स्तंभ निम्न कोड से प्राप्त कर सकते हैं जहाँ arr[,2,1] में स्पेस के साथ 2 दूसरा स्तंभ है, और 1 उस 'arr' को दर्शाता है जिसे निकाला जाना है।

mat[ ,2,1]

r1

4

r2

5

r3

6

उपरोक्त कोड नीचे जैसा आउटपुट देता है और r1, r2, r3 भी प्रिंट करता है।

r1 4
r2 5
r3 6

मैट्रिस बनाना और जोड़

आइए 'arr[ , ,1]' से mat1 और mat2 नाम की मैट्रिस बनाएँ जहाँ 'arr' की सभी पंक्तियाँ और स्तंभ कॉपी हो जाते हैं।

mat1 = arr[,,1]
mat2 = arr[,,1]

   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18 

दो मैट्रिस 'mat1' और 'mat2' को जोड़ें और परिणाम final में रखें। आउटपुट भी प्रिंट किया गया है।

final <- mat1+mat2
print(final)

नीचे के आउटपुट से पता चलता है कि mat1 और mat2 की प्रत्येक पंक्ति और स्तंभ एक-दूसरे से जोड़े गए हैं।

   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18 

apply()

'apply()' R पैकेजों में से एक का हिस्सा है जिसमें कई फ़ंक्शन होते हैं जो कोड को आसान और कुशल तरीके से लिखने में मदद करते हैं। नीचे आप उदाहरण देखेंगे जहाँ इसका उपयोग दो अलग-अलग arrays के योग की गणना करने के लिए किया जा सकता है।

apply() का सिंटैक्स है:
apply(x, margin, function)

ऊपर के आर्गुमेंट का अर्थ है:
x: एक array या मैट्रिस के रूप में दो-आयामी डेटा।
margin: दर्शाता है कि किस margin मान पर फ़ंक्शन लागू करना है — पंक्तियों के लिए c(1), स्तंभों के लिए c(2), और दोनों पंक्तियों व स्तंभों के लिए c(1,2)।
function: वह R-निर्मित (built-in) या उपयोगकर्ता-परिभाषित फ़ंक्शन जो दिए गए डेटा पर लागू किया जाएगा।

आइए नीचे दिए गए कोड से 'array1' नाम का लंबाई तीन का और 'array2' नाम का लंबाई छह का वेक्टर बनाएँ।

array1 = c(5,10,15)
array2 = c(15,20,25,30,35,40)

आप नीचे देख सकते हैं जहाँ 'array()' 'array1' और 'array2' नाम के दो वेक्टर स्वीकार करता है, 3 पंक्तियाँ, 3 स्तंभ के आयाम के साथ, और 2 मैट्रिस बनाई जाती हैं और 'my. Array' में संग्रहीत होती हैं।

my.Array <- array(c(array1,array2),dim = c(3,3,2))
print(my.Array)

, , 1

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

, , 2

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

उपरोक्त कोड निम्न आउटपुट देता है, जहाँ 3 3 (पंक्तियाँ स्तंभ) के साथ दो मैट्रिस बनाई जाती हैं।

, , 1

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

, , 2

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

'apply()' का उपयोग नीचे स्तंभ-वार दो मैट्रिस के योग की गणना करने के लिए किया गया है।

final <- apply(my.Array, c(2), sum)
print(final)

[1]  60 120 210

आप ऊपर देख सकते हैं कि margin के लिए c(2) उपयोग किया गया है, जहाँ 'my. Array' की मैट्रिस के तत्वों का स्तंभ-वार योग लिया गया है जिससे निम्न आउटपुट प्राप्त होता है।

60 120 210

अंत में, नीचे 'apply()' का उपयोग पंक्ति-वार दो मैट्रिस के योग की गणना करने के लिए किया गया है।

final <- apply(my.Array, c(1), sum)
print(final)

[1] 100 130 160

आप ऊपर देख सकते हैं कि margin के लिए c(1) उपयोग किया गया है, जहाँ 'my. Array' की मैट्रिस के तत्वों का पंक्ति-वार योग लिया गया है जिससे निम्न आउटपुट प्राप्त होता है।

100 130 160

बधाई हो

बधाई हो, आप इस ट्यूटोरियल के अंत तक पहुँच गए हैं!

आपने R के Array के बारे में सीखा, उसके निर्माण, उदाहरणों सहित array में indexing, साथ ही मैट्रिस के निर्माण और जोड़, तथा apply() फ़ंक्शन के बारे में भी जाना।

यदि आप R के बारे में और सीखना चाहते हैं, तो DataCamp का Introduction to R कोर्स करें।

संदर्भ:
R-Arrays
R Array Function and Create Array in R