R Academy · पाठ

मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण

मैट्रिक्स पर t(), dim() और reshape संचालन का उपयोग करें।

पाठ 4, कुल 4 में से13 चरण

मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

t() से मैट्रिक्स का ट्रांसपोज़ करना

t(m) मैट्रिक्स को ट्रांसपोज़ करता है — यह पंक्तियों और स्तंभों की अदला-बदली करता है, इसलिए परिणाम में पंक्ति i स्तंभ i बन जाती है। आयाम भी बदल जाते हैं: ट्रांसपोज़ करने के बाद 3x4 मैट्रिक्स 4x3 मैट्रिक्स बन जाता है।

m <- matrix(1:6, nrow = 2, ncol = 3)
cat('Original (2x3):
'); print(m)
cat('Transposed (3x2):
'); print(t(m))
cat('Original dim:', dim(m), '-> Transposed dim:', dim(t(m)), '
')

नामित आयामों के साथ ट्रांसपोज़ करना

जब किसी मैट्रिक्स में पंक्तियों और स्तंभों के नाम होते हैं, तो t() नामों की सही अदला-बदली करता है: पंक्ति-नाम स्तंभ-नाम बन जाते हैं और इसके विपरीत। इससे ट्रांसपोज़ करने के बाद भी आपका डेटा नामों सहित बना रहता है।

scores <- matrix(
  c(88,92,75, 79,85,90),
  nrow = 2, byrow = TRUE,
  dimnames = list(c('Alice', 'Bob'), c('Math', 'Sci', 'Eng'))
)
cat('Original (students x subjects):
'); print(scores)
cat('Transposed (subjects x students):
'); print(t(scores))

dim(m) <- c(r, c) से आकार बदलना

आप dim विशेषता को फिर से असाइन करके मैट्रिक्स का आकार बदल सकते हैं। तत्वों की कुल संख्या समान रहनी चाहिए। आकार बदलते समय मान स्तंभ-दर-स्तंभ पढ़े और भरे जाते हैं, ठीक matrix() की तरह।

m <- matrix(1:12, nrow = 3, ncol = 4)
cat('Original (3x4):
'); print(m)

# Reshape to 4x3
dim(m) <- c(4, 3)
cat('Reshaped to (4x3):
'); print(m)

# Reshape to 6x2
dim(m) <- c(6, 2)
cat('Reshaped to (6x2):
'); print(m)

as.vector() से मैट्रिक्स को vector में बदलना

as.vector(m) मैट्रिक्स को एक-आयामी vector में बदलता है और मानों को स्तंभ-दर-स्तंभ पढ़ता है। इससे ऑब्जेक्ट की सभी आयाम विशेषताएँ हट जाती हैं।

m <- matrix(c(10,20,30,40,50,60), nrow = 2, ncol = 3)
cat('Matrix:
'); print(m)

v <- as.vector(m)
cat('As vector (col-by-col):', v, '
')
cat('Is vector:', is.vector(v), '
')
cat('Is matrix:', is.matrix(v), '
')

as.matrix() से vector को मैट्रिक्स में बदलना

as.matrix(v) किसी vector को एकल-स्तंभ मैट्रिक्स में बदलता है। यह सबसे सरल रूपांतरण है। इसके बाद वांछित आयाम पाने के लिए आप dim() का उपयोग करके इसका आकार बदल सकते हैं।

v <- c(5, 10, 15, 20, 25, 30)
cat('Vector:', v, '
')

# as.matrix makes a 6x1 matrix
m_single_col <- as.matrix(v)
cat('Single-column matrix:
'); print(m_single_col)
cat('Dimensions:', dim(m_single_col), '
')

rbind() — पंक्तियों को एक के ऊपर एक रखना

rbind() मैट्रिक्स या vector को पंक्तियों को एक के ऊपर एक रखकर संयोजित करता है। सभी इनपुट में स्तंभों की संख्या समान होनी चाहिए। परिणामी मैट्रिक्स में पंक्तियों की संयुक्त संख्या होती है।

first_half <- matrix(1:6, nrow = 2, ncol = 3)
second_half <- matrix(7:12, nrow = 2, ncol = 3)

combined <- rbind(first_half, second_half)
cat('rbind result (4x3):
'); print(combined)
cat('Dimensions:', dim(combined), '
')

cbind() — स्तंभों को जोड़ना

cbind() मैट्रिक्स या vector को बगल-बगल स्तंभ जोड़कर संयोजित करता है। सभी इनपुट में पंक्तियों की संख्या समान होनी चाहिए। परिणाम में स्तंभों की संयुक्त संख्या होती है।

ids <- matrix(101:104, nrow = 4, ncol = 1)
scores_mat <- matrix(c(88,79,95,72, 92,85,78,90), nrow = 4)

full_data <- cbind(ids, scores_mat)
colnames(full_data) <- c('ID', 'Test1', 'Test2')
cat('cbind result:
'); print(full_data)

नामित पंक्तियों/स्तंभों के साथ rbind() और cbind()

जब आप नामित मैट्रिक्स या नामित vector पर rbind() या cbind() लागू करते हैं, तो आयाम-नाम बने रहते हैं (और vector के मामले में, vector के नाम पंक्ति या स्तंभ-नाम बन जाते हैं)।

# Add a new student row with rbind
existing <- matrix(c(88,92,75, 79,85,90), nrow = 2, byrow = TRUE,
                   dimnames = list(c('Alice','Bob'), c('Math','Sci','Eng')))
new_student <- c(Math=95, Sci=78, Eng=82)
updated <- rbind(existing, Carol = new_student)
cat('Updated roster:
'); print(updated)

दो बार ट्रांसपोज़ करने की पहचान

t() को दो बार लागू करने पर मूल मैट्रिक्स वापस मिलता है। यह एक उपयोगी तर्कसंगतता जाँच है और दिखाता है कि ट्रांसपोज़ करना स्वयं का प्रतिलोम ऑपरेशन है: t(t(m)) == m।

m <- matrix(c(1,2,3,4,5,6), nrow = 2)
cat('Original:
'); print(m)
cat('t(m):
');    print(t(m))
cat('t(t(m)):
'); print(t(t(m)))
cat('t(t(m)) == m:', all(t(t(m)) == m), '
')

व्यावहारिक: पिवट-शैली में आकार बदलना

आकार बदलने का एक सामान्य कार्य विस्तृत और लंबे प्रारूपों के बीच रूपांतरण करना है। यहाँ हम मैट्रिक्स संक्रियाओं — ट्रांसपोज़ करना, सपाट बनाना और संरचना फिर से बनाना — का उपयोग करके विस्तृत से लंबे प्रारूप में मैन्युअल पिवट का अनुकरण करते हैं।

# Wide: 3 students x 4 months scores
wide <- matrix(c(85,88,90,92, 78,80,79,83, 91,94,88,95),
               nrow = 3, byrow = TRUE)
rownames(wide) <- c('Alice', 'Bob', 'Carol')
colnames(wide) <- c('Jan', 'Feb', 'Mar', 'Apr')
cat('Wide format:
'); print(wide)

# Transposed: 4 months x 3 students
long_view <- t(wide)
cat('Transposed (months x students):
'); print(long_view)

आकार बदलने और संयोजन का सारांश

मैट्रिक्स के लिए आकार बदलने और संयोजन के प्रमुख उपकरण:

  • t(m) — ट्रांसपोज़ करना (पंक्तियों और स्तंभों की अदला-बदली)
  • dim(m) <- c(r, c) — वहीं पर आकार बदलना (तत्वों की कुल संख्या समान होनी चाहिए)
  • as.vector(m) — 1D vector में सपाट करना (स्तंभ-प्रधान क्रम)
  • as.matrix(v) — vector को स्तंभ मैट्रिक्स में बदलना
  • rbind(...) — मैट्रिक्स को लंबवत रूप से एक के ऊपर एक रखना
  • cbind(...) — मैट्रिक्स को क्षैतिज रूप से जोड़ना
# Demo all tools
v <- 1:6
m1 <- as.matrix(v)               # 6x1
dim(m1) <- c(2, 3)               # reshape to 2x3
m2 <- t(m1)                      # 3x2
m3 <- cbind(m2, c(10, 20, 30))   # 3x3
cat('Final matrix:
'); print(m3)

त्वरित जाँच

t(matrix(1:12, nrow = 3, ncol = 4)) से कौन से आयाम प्राप्त होते हैं?

पुनरावलोकन: ट्रांसपोज़ करना और आकार बदलना

बहुत बढ़िया! इस पाठ की मुख्य बातें:

  • t(m) पंक्तियों और स्तंभों की अदला-बदली करता है; t(t(m)) मूल मैट्रिक्स लौटाता है
  • dim(m) <- c(r, c) बिना प्रतिलिपि बनाए आकार बदलता है (तत्वों की संख्या समान होना आवश्यक है)
  • as.vector() स्तंभ-दर-स्तंभ सपाट करता है; as.matrix() एकल-स्तंभ मैट्रिक्स बनाता है
  • rbind() पंक्तियों को एक के ऊपर एक रखता है (स्तंभों की समान संख्या आवश्यक है)
  • cbind() स्तंभों को बगल-बगल जोड़ता है (पंक्तियों की समान संख्या आवश्यक है)
  • इन संक्रियाओं के दौरान नामित आयाम बने रहते हैं
# Practical: merge data then compute column means
team_a <- matrix(c(82,78,91, 85,80,88), nrow = 2, byrow=TRUE)
team_b <- matrix(c(75,92,79, 88,84,93), nrow = 2, byrow=TRUE)
all_teams <- rbind(team_a, team_b)
colnames(all_teams) <- c('Speed', 'Accuracy', 'Strength')
cat('Combined teams:
'); print(all_teams)
cat('Average per skill:', colMeans(all_teams), '
')
शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
43
पाठ
159

अक्सर पूछे जाने वाले प्रश्न

क्या “मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण” में मैं क्या सीखूँगा?

मैट्रिक्स पर t(), dim() और reshape संचालन का उपयोग करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. matrix() से मैट्रिक्स बनाना
  2. मैट्रिक्स इंडेक्सिंग और सबसेटिंग
  3. मैट्रिक्स अंकगणित और संचालन
  4. मैट्रिक्स का ट्रांसपोज़ और पुनःआकार निर्धारण
← R Academy पर वापस जाएँ