ஜாவாவில் துண்டிக்கப்பட்ட வரிசைகள்

"வணக்கம், என் மிகவும் புத்திசாலி மாணவர்!"

"ஹலோ ரிஷி!"

"வரிசைகளைப் பற்றிய புதிய விவாதத்திற்கு நீங்கள் ஆர்வமாக உள்ளீர்களா? சரி, இன்று உங்களுக்காக ஒன்று உள்ளது! இன்று நான் உங்களுக்கு துண்டிக்கப்பட்ட மற்றும் பல பரிமாண வரிசைகளைப் பற்றி சொல்லப் போகிறேன்."

"இரத்தவெறி மற்றும் பயமுறுத்துகிறது."

"கவலைப்பட வேண்டாம், ஒரு உண்மையான ப்ரோக்ராமர் ஒரு வரிசையை அதன் பற்களைக் காட்டினாலும் அதைக் கையாள முடியும். நகைச்சுவைகள் ஒருபுறம் இருக்க, ஒரு வரிசையின் துறுதுறுப்பானது இரு பரிமாண வரிசையின் வரிசைகளை மாற்றுவது மட்டுமல்லாமல், ஒரு வரிசையை உருவாக்கும் திறனையும் பிரதிபலிக்கிறது. இருப்பினும் அது இருக்க வேண்டும்.

"இரு பரிமாண அணிவரிசையின் முதல் வரிசை 10 ஆகவும், இரண்டாவது 50 ஆகவும் இருக்க வேண்டும் என்று நீங்கள் விரும்புகிறீர்கள் என்று வைத்துக் கொள்வோம்."

"உங்களால் அப்படிச் செய்ய முடியுமா?"

"நிச்சயமாக! முதலில், 'கன்டெய்னர்கள் கொண்ட கொள்கலன்' ஒன்றை உருவாக்குகிறோம் - இது முதல் வரிசையாகும், இது வரிசைகளின் வரிசைகளுக்கான குறிப்புகளை சேமிக்கும். இது இவ்வாறு செய்யப்படுகிறது:

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

"நீங்கள் இரண்டாவது பரிமாணத்தைத் தவிர்க்கிறீர்கள் , ஜாவா இயந்திரம் கொள்கலன்களின் கொள்கலனை உருவாக்குகிறது. இந்தக் குறியீட்டை இயக்கிய பிறகு இதுதான் நினைவகத்தில் இருக்கும்:

"மேலும், ஒரு பரிமாண வரிசைகளை எவ்வாறு உருவாக்குவது என்பது உங்களுக்கு ஏற்கனவே தெரியும் 🙂

இதன் விளைவாக வரும் குறியீடு இப்படி இருக்கும்:

// Matrix of important data
int[][] matrix = new int[2][];
matrix[0] = new int[10];
matrix[1] = new int[50]

"நாங்கள் இப்போது "துண்டிக்கப்பட்ட" வரிசை என்று அழைக்கப்படுவதை உருவாக்கியுள்ளோம் . அதன் விளிம்புகள் கரடுமுரடானவை மற்றும் ஒழுங்கற்றவை.

"மேலும் நாம் இப்போது இந்த வரிசையின் அனைத்து கூறுகளையும் திரையில் காட்ட விரும்பினால், வரிசையின் lengthவரிசை கைக்குள் வரும்: எல்லாவற்றிற்கும் மேலாக, வரிசையின் வரிசைகளின் நீளம் வேறுபட்டது.

"எங்கள் உதாரணத்தில், 'கன்டெய்னர் ஆஃப் கன்டெய்னர்' நீளத்தை எப்படிக் கண்டுபிடிப்பது என்று சொல்ல முடியுமா? அதுவும் ஒரு வரிசைப் பொருளாகும், அதாவது நீளம் கொண்டது."

"ஒருவேளை matrix.length?"

"மிகவும் சரி! மற்றும் வரிசைகளை உருவாக்கும் வரிசைகளுக்கு, matrix[0].lengthபூஜ்ஜிய வரிசையைப் பயன்படுத்துவோம்."

"முதலில், நாம் பயன்படுத்துவோம் என்று அர்த்தம் matrix[1].length?"

"மிகவும் சரி. முதல் வழக்கில், கட்டளையை இயக்கினால் 10 கிடைக்கும், இரண்டாவது வழக்கில், முடிவு 50 ஆக இருக்கும்.

இரு பரிமாண வரிசையுடன் பணிபுரிதல்

"இப்போது இரு பரிமாண வரிசையைக் காட்ட முயற்சிப்போம்:

int[][] matrix = new int[3][];
matrix[0] = {1, 2, 3, 4, 5, 6};
matrix[1] = {1, 2, 3};
matrix[2] = {1};
for (int i = 0; i < matrix.length; i++)
{
   for (int j = 0; j < matrix[i].length; j++)
      System.out.print( matrix[i][j] + " " );
   System.out.println();
}

"நீங்கள் பார்க்க முடியும் என, எங்களுக்கு இரண்டு உள்ளமை சுழல்கள் தேவை. முதலில் நாம் வெளிப்புறமாக அழைக்கிறோம், இரண்டாவது - உள் .

"வெளிப்புற சுழற்சியில் ( iமாறி), நமது இரு பரிமாண வரிசையை உருவாக்கும் அனைத்து வரிசைகள் (வரிசைகள்) வழியாக தொடர்ச்சியாக செல்கிறோம். ஒவ்வொரு மதிப்பும் iஅந்த குறியீட்டுடன் ஒரு வரிசைக்கு ஒத்திருக்கிறது.

"உள் சுழற்சியில் ( jமாறி), வரிசைகளில் உள்ள அனைத்து செல்கள் மீதும் மீண்டும் மீண்டும் செய்கிறோம். உள் சுழற்சிக்கு நன்றி, ஒரு பரிமாண வரிசையின் மதிப்புகளைக் கொண்ட ஒரு வரிசை திரையில் காட்டப்படும்.

"இது காட்டப்படும்:

பல பரிமாண வரிசைகள்

"அமிகோ! இரு பரிமாண வரிசைகள் இருந்தால், முப்பரிமாணங்களும் இருக்கலாம் என்று நீங்கள் யூகித்தீர்களா?

"நான் அதைப் பற்றி யோசித்துக்கொண்டிருந்தேன், ஆனால் கேட்க வெட்கமாக இருந்தது.

"ஆம், நீங்கள் ஒரு முப்பரிமாண வரிசையை உருவாக்கலாம், பொதுவாக, எந்த பரிமாணத்தின் வரிசையையும் உருவாக்கலாம். அத்தகைய அணிகள் 'பல பரிமாணங்கள்' என்று அழைக்கப்படுகின்றன. வேடிக்கைக்காக, 4 பரிமாணங்களைக் கொண்ட பல பரிமாண வரிசையை உருவாக்குவோம்.

 int[][][][] matrix = new int[2][3][4][5];

"அது மிகவும் கடினமாகத் தெரியவில்லை!"

"நீங்கள் இன்னும் கைமுறையாக ஒன்றை உருவாக்க முயற்சிக்கவில்லை! இதோ, இதை உங்கள் கண்களுக்கு விருந்தளிக்கவும்:

int[][][][] matrix;
matrix = new int[2][][][];                   // Create a 2-element array of references to references to references
for (int i = 0; i < matrix.length; i++)
{
  matrix[i] = new int[3][][];                // Create a 3-element array of references to references
  for (j = 0; j < matrix[i].length; j++)
  {
    matrix[i][j] = new int[4][];             // Create a 4-element array of references
    for (k = 0; k < matrix[i][j].length; k++)
      matrix[i][j][k] = new int[5];          // Create 5-element arrays of integers
  }
}

"அது ஒரு வரிசையை உருவாக்குகிறது! பிறகு நீங்களும் எப்படியாவது அதனுடன் வேலை செய்ய வேண்டும்."

"நான் சொன்னதை திரும்பப் பெறுகிறேன். அவர்களுடன் இணைந்து பணியாற்றுவது அவ்வளவு எளிதானது அல்ல. ஆனால் அது சாத்தியம்."

"இது சாத்தியம் என்பதால், இங்கே ஒரு போனஸ் பணி உள்ளது. முப்பரிமாண வரிசையில் அனைத்து மதிப்புகளையும் காண்பிக்கும் குறியீட்டை எழுதுங்கள். இதைச் செய்ய உங்களுக்கு போதுமான அளவு தெரியும். முக்கிய விஷயம் பொறுமையாகவும் கவனமாகவும் இருக்க வேண்டும். அல்லது சமயோசிதமாக இருக்கலாம் (ஒரு ரகசிய பிட் உள்ளது இந்த பணியை ஒரே வரியில் தீர்க்க உதவும் அறிவு).

"நன்றி ரிஷி. நான் முயற்சி செய்கிறேன்."