जावा int [] [] सरणी - पुनरावृत्ति और मूल्य

Question

मेरे पास 'int[][]' के रूप में एक सरणी है जो एक छोटे ग्रिड के समन्वय का प्रतिनिधित्व करती है। प्रत्येक समन्वय को अपना मूल्य सौंपा गया है। उदाहरण के लिए array[0][4] = 28 ......

मेरे दो प्रश्न हैं। सबसे पहले, मैं सभी संग्रहीत मूल्यों के माध्यम से कैसे पुन: प्रयास करूं। दूसरा, मैं एक मूल्य इनपुट करने में सक्षम होना चाहता हूं और ग्रिड में अपने विशिष्ट समन्वय प्राप्त करना चाहता हूं। इस तक पहुंचने का सबसे अच्छा तरीका क्या होगा?

किसी भी मदद के लिए धन्यवाद! से अधिक मूल्यों छोरों का उपयोग

Answer 1

आप के साथ या तो छोरों के लिए पुनरावृति या छोरों के लिए बढ़ाया जा सकता है:

for (int row=0; row < grid.length; row++) 
{ 
    for (int col=0; col < grid[row].length; col++) 
    { 
     int value = grid[row][col]; 
     // Do stuff 
    } 
} 

या

// Note the different use of "row" as a variable name! This 
// is the *whole* row, not the row *number*. 
for (int[] row : grid) 
{ 
    for (int value : row) 
    { 
     // Do stuff 
    } 
} 

पहले संस्करण "समन्वय लगता है" प्रश्न के सबसे आसान समाधान हो सकता है - बस जांचें कि आंतरिक पाश में मान सही है या नहीं।

Answer 2

पुनरावृत्ति करने के लिए:

int[][] matrix 
//... 
for(int row[] : matrix) 
    for(int cell : row){ 
     //do something with cell 
    } 

मूल्य आप (java.util.HashMap पर एक नज़र) डबल hashmap के कुछ प्रकार की आवश्यकता होगी के आधार पर निर्देशांक तक पहुँचने के लिए, लेकिन मैं के बारे में पता कर रहा हूँ ऐसा कुछ भी नहीं जो सीधे

Answer 3

जब तक कि आपकी ग्रिड किसी तरह से हल नहीं हो जाती है, तो संभवतः आप ब्रूट फोर्स सर्च से बेहतर नहीं करेंगे।

बार-बार दोहराना के लिए, मुझे लगता है कि यह कुछ इस तरह होगा (वाक्य रचना, थोड़ा दूर हो सकता है मैं थोड़ी देर के लिए जावा में सरणियों के साथ पेश नहीं किया है।):

int[][] grid; // just assuming this is already assigned somewhere 

for(int x = 0 ; x < grid.length ; x++) { 
    int[] row = grid[x]; 
    for(int y = 0 ; y < row.length ; y++) { 
    int value = row[y]; 
    // Here you have the value for grid[x][y] and can do what you need to with it 
    } 
} 

आप चाहते खोज के लिए शायद इसे फिर से उपयोग करने के लिए उपयोग करने की आवश्यकता है, फिर इसे प्राप्त करने के बाद वापस लौटें।

यदि आप एक ही मूल्य की स्थिति को कई बार देख रहे हैं तो हो सकता है कि आप हैशटेबल का उपयोग करके परिणामों को याद रखना चाहें।

Answer 4

ग्रिड में सभी तत्वों से अधिक पुनरावृति करने के लिए इस प्रयास करें:

int grid[][] = new int[10][10]; 

for(int i = 0; i < grid.length(); ++i) { 
    for(int j = 0; j < grid[i].length(); ++j) { 
     // Do whatever with grid[i][j] here 
    } 
} 

Answer 5

वहाँ आम तौर पर सरणी के माध्यम से जा रहा है और खोज करके उसे छोड़कर एक विशेष मूल्य के विशिष्ट निर्देशांक खोजने के लिए कोई रास्ता नहीं है। हालांकि, यदि सरणी में मान अद्वितीय होने की गारंटी है (यानी प्रत्येक मान केवल एक सेल में होता है), तो आप एक इंडेक्स के रूप में एक अलग सरणी बनाए रख सकते हैं, जो मान द्वारा अनुक्रमित प्रत्येक मान के निर्देशांक को संग्रहीत करता है।

Answer 6

एक्स और वाई आयामों पर फिर से चलाने के लिए लूप के लिए नेस्टेड का उपयोग करें, जो आपको एक समय में प्रत्येक मान पर जाने देता है।

मूल्य इनपुट करने के लिए, बस उपर्युक्त जैसा ही करें, लेकिन अपने अनुरोधित मान से मिलान की तलाश करें।

Answer 7

यदि आप इन सभी संग्रहों को एक ही कक्षा में अवरुद्ध करते हैं तो आप सबसे खुश होंगे और उन्हें किसी भी तरह से बेनकाब न करें।

इसका मतलब है कि इस कक्षा में अपनी खोज और लुकअप दिनचर्या भी ले जाएं।

भंडारण के लिए, सभी को कवर किया गया है, एक हैशटेबल और लुकअप जोड़ें।मैंने निकोलाई के पोस्ट पर यह टिप्पणी डाली:

अपनी हैश तालिका में मान के रूप में नया इंटीजर (ix + iy * 1000) स्टोर करें। यदि आपकी वाई इंडेक्स 1000 से अधिक हो सकती है तो बड़ी संख्या में उपयोग करें - इनट्स वास्तव में बड़े हैं। इसे वापस पाने के लिए ix = val% 1000, iy = val/1000।

यदि आपकी सरणी और हैशटेबल एक ही कक्षा में encapsulated हैं, तो आपका शेष कोड लिखना बहुत आसान होगा और बहुत साफ होगा।