రెండు డైమెన్షనల్ శ్రేణులు

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.

"నమస్కారాలు, అమిగో!"

"హలో, రిషీ!"

"మీకు శ్రేణుల గురించి ఇప్పటికే ఒకటి లేదా రెండు విషయాలు తెలుసు, మరియు మీరు కొన్ని పనులను కూడా పరిష్కరించగలిగారు, నేను ఆశిస్తున్నాను. కానీ మీకు అన్నీ తెలియవు. ఉదాహరణకు, శ్రేణుల గురించి మరొక ఆసక్తికరమైన విషయం ఇక్కడ ఉంది. శ్రేణులు ఒక డైమెన్షనల్ మాత్రమే కాదు (లీనియర్ ) అవి ద్విమితీయంగా కూడా ఉంటాయి."

"అమ్మో... దాని అర్థం ఏమిటి?"

"దీని అర్థం శ్రేణి యొక్క కణాలు నిలువు వరుస (లేదా అడ్డు వరుస) మాత్రమే కాకుండా దీర్ఘచతురస్రాకార పట్టికను కూడా సూచిస్తాయి.

int[][]name = new int[width][height];

"ఎక్కడ పేరు అర్రే వేరియబుల్ పేరు, వెడల్పు పట్టిక వెడల్పు (సెల్‌లలో) మరియు ఎత్తు అనేది పట్టిక ఎత్తు. ఒక ఉదాహరణను చూడండి:

int[][] data = new int[2][5];
data[1][1] = 5;

"ఇది మెమరీలో ఇలా కనిపిస్తుంది:

"మార్గం ద్వారా, రెండు డైమెన్షనల్ శ్రేణుల కోసం, మీరు వేగవంతమైన ప్రారంభాన్ని కూడా ఉపయోగించవచ్చు:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

"హ్మ్... ఇప్పుడు అది ఆసక్తికరంగా ఉంది. మొదటి లోపలి బ్రాకెట్లలో ఒక మూలకాన్ని సూచిస్తే, తదుపరిది రెండవది... కాబట్టి ద్విమితీయ శ్రేణి శ్రేణుల శ్రేణిలా ఉంటుందా?"

"మీరు ఎంత తెలివైన విద్యార్థి! సరిగ్గా. మొదటి మూలకం ఒక డైమెన్షనల్ శ్రేణి {31, 28, 31}, రెండవది {30, 31, 30}, మరియు మొదలైనవి. కానీ మేము ఈ పాఠంలో కొంచెం తర్వాత తిరిగి వస్తాము. అప్పటి వరకు, ఆలోచించడానికి ప్రయత్నించండి రెండు డైమెన్షనల్ శ్రేణి అడ్డు వరుసలు మరియు నిలువు వరుసలతో పట్టికగా, ప్రతి ఖండన వద్ద సెల్‌లను ఏర్పరుస్తుంది.

"నాకు దాని గురించి ఒక మానసిక చిత్రం ఉంది. మార్గం ద్వారా, ఈ రెండు డైమెన్షనల్ శ్రేణులు దేనికి ఉపయోగించబడ్డాయి?"

"ప్రోగ్రామర్‌కు చాలా తరచుగా రెండు డైమెన్షనల్ శ్రేణులు అవసరం. మీరు నిశితంగా పరిశీలిస్తే, దాదాపు ఏదైనా బోర్డ్ గేమ్ ఆఫ్-ది-షెల్ఫ్ టూ-డైమెన్షనల్ శ్రేణిని ఉపయోగించి అమలు చేయబడుతుంది: చదరంగం, చెకర్స్, టిక్-టాక్-టో, సముద్ర యుద్ధం మొదలైనవి:"

"నాకు అర్థమైంది! చదరంగం లేదా సముద్ర యుద్ధం యొక్క మైదానం రెండు డైమెన్షనల్ శ్రేణులకు సరిగ్గా సరిపోతుంది!"

"అవును, అయితే మీరు సెల్ కోఆర్డినేట్‌ల వలె సంఖ్యలను ఉపయోగించాలి. 'పాన్ e2-e4' కాదు, కానీ 'పాన్ (5,2) -> (5,4)'. ఇది ప్రోగ్రామర్‌గా మీకు మరింత సులభంగా ఉంటుంది. "

శ్రేణులలో మూలకాలను అమర్చడం: (x, y) లేదా (y, x)

"రెండు-డైమెన్షనల్ శ్రేణులను సృష్టించడం ఒక ఆసక్తికరమైన గందరగోళాన్ని పెంచుతుంది. మేము ఉపయోగించి శ్రేణిని సృష్టించినప్పుడు , మనకు 'రెండు అడ్డు వరుసలు మరియు 5 నిలువు వరుసలుnew int [2][5]; ' పట్టిక ఉందా లేదా అది 'రెండు నిలువు వరుసలు మరియు 5 వరుసలు' ఉందా?"

"మరో మాటలో చెప్పాలంటే, మనం మొదట వెడల్పును మరియు ఆపై 'ఎత్తును... లేదా వైస్ వెర్సా, మొదట ఎత్తు మరియు తరువాత వెడల్పును పేర్కొంటున్నామా అనేది పూర్తిగా స్పష్టంగా తెలియదా?"

"అవును, ఇది సందిగ్ధత. మరియు ఖచ్చితమైన సమాధానం లేదు."

"ఏం చేయాలి?"

"మొదట, మన ద్విమితీయ శ్రేణి మెమరీలో ఎలా నిల్వ చేయబడిందో అర్థం చేసుకోవడం చాలా ముఖ్యం . సహజంగానే, కంప్యూటర్ మెమరీలో వాస్తవానికి ఎటువంటి పట్టికలు లేవు: మెమరీలోని ప్రతి స్థానానికి వరుస సంఖ్యా చిరునామా ఉంటుంది: 0, 1, 2, ... మాకు, ఇది 2 × 5 పట్టిక, కానీ మెమరీలో ఇది కేవలం 10 సెల్‌లు, మరేమీ కాదు. అడ్డు వరుసలు మరియు నిలువు వరుసలుగా విభజించబడదు."

"నేను దానిని అర్థం చేసుకున్నాను. అప్పుడు ఏ పరిమాణం మొదట వస్తుందో - వెడల్పు లేదా ఎత్తును ఎలా నిర్ణయిస్తాము?"

"మొదటి ఎంపికను పరిశీలిద్దాం. మొదట వెడల్పు, ఆపై ఎత్తు. "ఈ విధానానికి అనుకూలంగా వాదన ఇది: ప్రతి ఒక్కరూ పాఠశాలలో గణితాన్ని నేర్చుకుంటారు మరియు సమన్వయ జతలను 'x' (అంటే, సమాంతర అక్షం) అని వ్రాస్తారని వారు తెలుసుకుంటారు. ఆపై 'y' (నిలువు పరిమాణం). మరియు ఇది కేవలం పాఠశాల ప్రమాణం కాదు — ఇది గణితశాస్త్రంలో సాధారణంగా ఆమోదించబడిన ప్రమాణం. వారు చెప్పినట్లు, మీరు గణితంతో వాదించలేరు."

"అదేనా? సరే, మనం పోరాడలేకపోతే, మొదట వెడల్పు మరియు తరువాత ఎత్తు?"

" మొదట ఎత్తు, ఆపై వెడల్పు'కు అనుకూలంగా ఒక ఆసక్తికరమైన వాదన ఉంది . ఈ ఆర్గ్యుమెంట్ ద్విమితీయ శ్రేణుల వేగవంతమైన ప్రారంభీకరణ నుండి వచ్చింది. అన్నింటికంటే, మన శ్రేణిని ప్రారంభించాలనుకుంటే, మేము ఇలా కోడ్‌ను వ్రాస్తాము:"

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

"కాబట్టి అది మనకు ఏమి చేస్తుంది?"

"మీరేమైనా గమనించారా? ఇది మన దగ్గర ఉంటే?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

"మేము మా డేటాను కోడ్ లైన్‌లో లైన్ ద్వారా వ్రాస్తే, మేము 2 అడ్డు వరుసలు మరియు 5 నిలువు వరుసలతో కూడిన పట్టికను పొందుతాము."

"ఇప్పుడు నేను చూస్తున్నాను. 2 ఎత్తు, మరియు 5 వెడల్పు... కాబట్టి మనం ఏ ఎంపికను ఉపయోగించాలి?"

"ఏది మరింత సౌకర్యవంతంగా ఉంటుందో నిర్ణయించుకోవడం మీ ఇష్టం. అత్యంత ముఖ్యమైన విషయం ఏమిటంటే, ఒకే ప్రాజెక్ట్‌లో పనిచేసే ప్రోగ్రామర్లందరూ ఒకే విధానాన్ని అనుసరించడం."

"మీరు ఒక ప్రాజెక్ట్‌లో పని చేస్తే, కోడ్‌లో చాలా ప్రారంభమైన రెండు-డైమెన్షనల్ శ్రేణులు ఉన్నాయి, అప్పుడు చాలా మటుకు అక్కడ ప్రతిదీ వేగవంతమైన డేటా ప్రారంభించడంపై ఆధారపడి ఉంటుంది, అంటే మీరు ప్రామాణిక 'ఎత్తు x వెడల్పు'ని కలిగి ఉంటారు.

"మీరు చాలా గణితాన్ని కలిగి ఉన్న ప్రాజెక్ట్‌లో మిమ్మల్ని కనుగొంటే మరియు కోఆర్డినేట్‌లతో (ఉదాహరణకు, గేమ్ ఇంజిన్‌లు) పని చేస్తే, అప్పుడు కోడ్ ఎక్కువగా 'వెడల్పు x ఎత్తు' విధానాన్ని అవలంబిస్తుంది.

రెండు డైమెన్షనల్ శ్రేణులు ఎలా అమర్చబడి ఉంటాయి

"ఇప్పుడు, పాఠం ప్రారంభంలో మీరు గమనించిన రెండు డైమెన్షనల్ శ్రేణుల ప్రత్యేక లక్షణం మీకు గుర్తుందా?"

"అవును! రెండు డైమెన్షనల్ శ్రేణులు వాస్తవానికి శ్రేణుల శ్రేణులు!"

"చాలా సరైనది. "మరో మాటలో చెప్పాలంటే, ఒక సాధారణ శ్రేణి విషయంలో శ్రేణి వేరియబుల్ శ్రేణి మూలకాలను నిల్వ చేసే కంటైనర్‌కు సూచనను నిల్వ చేస్తే, ద్విమితీయ శ్రేణుల విషయంలో పరిస్థితి కొద్దిగా పేలుతుంది: రెండు డైమెన్షనల్ -array వేరియబుల్ ఒక డైమెన్షనల్ శ్రేణులకు సూచనలను నిల్వ చేసే కంటైనర్‌కు సూచనను నిల్వ చేస్తుంది. వందసార్లు వివరించడానికి ప్రయత్నించే బదులు ఒకసారి దాన్ని చర్యలో చూడటం మంచిది:"

"ఎడమవైపున , మనకు ద్విమితీయ-శ్రేణి వేరియబుల్ ఉంది, ఇది ద్విమితీయ-శ్రేణి వస్తువుకు సూచనను నిల్వ చేస్తుంది. మధ్యలో ద్విమితీయ శ్రేణి వస్తువు ఉంది, దీని కణాలు ఒక డైమెన్షనల్ శ్రేణులను నిల్వ చేస్తాయి, అవి ద్విమితీయ శ్రేణి యొక్క వరుసలు. మరియు కుడి వైపున , మీరు నాలుగు వన్-డైమెన్షనల్ శ్రేణులను చూడవచ్చు — మా ద్విమితీయ శ్రేణి యొక్క వరుసలు. వాస్తవానికి ద్విమితీయ శ్రేణులు ఈ విధంగా పని చేస్తాయి."

"అద్భుతం! కానీ అది మనకు ఏమి ఇస్తుంది?"

"కంటెయినర్ల కంటైనర్' 'వరుసల శ్రేణుల' సూచనలను నిల్వ చేస్తుంది కాబట్టి, మేము చాలా త్వరగా మరియు సులభంగా అడ్డు వరుసలను మార్చుకోవచ్చు. 'కంటైనర్‌ల కంటైనర్'ని పొందడానికి, మీరు కేవలం రెండు సూచికలకు బదులుగా ఒక సూచికను పేర్కొనాలి. ఉదాహరణ:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

"క్రింద ఉన్న కోడ్‌ని చూడండి. అడ్డు వరుసలను మార్చుకోవడానికి మేము దానిని ఉపయోగించవచ్చు:"

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

"అర్థమైంది. ఏదైనా రెండు సాధారణ వస్తువులను ఇచ్చిపుచ్చుకోవడం లాగా పని చేస్తుంది."

"అలా చేస్తుంది. మీరు ద్విమితీయ శ్రేణి యొక్క సెల్‌ని సూచిస్తే, కానీ మీరు శ్రేణి పేరు తర్వాత ఒక సూచికను మాత్రమే పేర్కొన్నట్లయితే, మీరు సాధారణమైన వాటికి సూచనలను నిల్వ చేసే కంటైనర్‌ల కంటైనర్‌ను సూచిస్తున్నారు- డైమెన్షనల్ శ్రేణులు."

"అంతా లాజికల్‌గా, క్లియర్‌గా ఉంది. లెక్చర్‌కి ధన్యవాదాలు, రిషీ!"

"మీకు స్వాగతం. తెలివిగా ఆచరణలో పెట్టండి."