जावा में स्प्लिट फंक्शन का उपयोग करके मैट्रिक्स में स्ट्रिंग खोजना

उदाहरण

import java.util.*; 

public class Demo { 
    public static int searchString(String[] myMatrix, String searchString) { 
        for (String input : myMatrix) { 
            String[] myValue = input.split(searchString); 
            if (myValue.length >= 2 || myValue.length == 0) { 
                return 1; 
            } else if (myValue.length == 1 && input.length() != myValue[0].length()) { 
                return 1; 
            } 
        } 
        return 0; 
    } 
    
    public static String[] verticalSearch(String[] myMatrix) { 
        String[] verticalSearchValue = new String[myMatrix[0].length()]; 
        for (int i = 0; i < myMatrix[0].length(); i++) { 
            String temp = ""; 
            for (int j = 0; j < myMatrix.length; j++) 
                temp += myMatrix[j].charAt(i); 
            verticalSearchValue[i] = temp; 
        } 
        return verticalSearchValue; 
    } 
    
    public static void main(String[] args) { 
        String[] myMatrix = { "This", "Sample", "This" }; 
        String searchString = "This"; 
        String[] verticalMatrix = verticalSearch(myMatrix); 
        int horizontalSearchResult = searchString(myMatrix, searchString); 
        int verticalSearchResult = searchString(verticalMatrix, searchString); 
        
        if (horizontalSearchResult == 1 || verticalSearchResult == 1) 
            System.out.println("स्ट्रिंग मैट्रिक्स में मिल गई"); 
        else 
            System.out.println("स्ट्रिंग मैट्रिक्स में नहीं मिली"); 
    } 
}

आउटपुट

स्ट्रिंग मैट्रिक्स में मिल गई

व्याख्या: Demo क्लास 'searchString' नामक एक फंक्शन परिभाषित करती है जो स्ट्रिंग को विभाजित करता है और स्ट्रिंग की लंबाई की जांच करता है। यदि पूरी पंक्ति स्ट्रिंग से भरी होती है, तो फंक्शन लंबाई 0 वाला ऐरे लौटाता है।

यदि हम जिस स्ट्रिंग को ढूंढ रहे हैं वह स्ट्रिंग के वर्णों के बीच में मौजूद है, तो ऐरे की लंबाई 1 से अधिक होगी। ऐरे की लंबाई 1 हो सकती है यदि:

• खोज स्ट्रिंग ऐरे के पहले भाग में होती है।
• खोज स्ट्रिंग ऐरे के अंतिम भाग में होती है।
• खोज स्ट्रिंग ऐरे में मौजूद नहीं है।

'verticalSearch' नामक एक अन्य फंक्शन मैट्रिक्स में खोज स्ट्रिंग को लंबवत जांचता है। मैट्रिक्स के कॉलम में स्ट्रिंग खोजने के लिए, मैट्रिक्स को ट्रांसपोज किया जाता है और फिर से खोजा जाता है।

एल्गोरिदम विश्लेषण:

• समय जटिलता: O(rows × cols × pattern_length)
• स्प्लिट-आधारित दृष्टिकोण सरल लेकिन इष्टतम नहीं
• केवल क्षैतिज और लंबवत खोजता है (विकर्ण नहीं)

सुधारित संस्करण (2D चार ऐरे के लिए):

public class MatrixSearch {
    public static boolean search(char[][] matrix, String word) {
        if (matrix == null || matrix.length == 0) return false;
        int rows = matrix.length, cols = matrix[0].length;
        
        // क्षैतिज खोज
        for (int r = 0; r < rows; r++) {
            String rowStr = new String(matrix[r]);
            if (rowStr.contains(word)) return true;
        }
        
        // लंबवत खोज
        for (int c = 0; c < cols; c++) {
            StringBuilder colStr = new StringBuilder();
            for (int r = 0; r < rows; r++) colStr.append(matrix[r][c]);
            if (colStr.toString().contains(word)) return true;
        }
        return false;
    }
}