मैं दो 2D सरणियों को तत्व के अनुसार कैसे जोड़ूं, इसके साथ परेशानी में चल रहा हूं। मैंने एक और पोस्ट का संदर्भ दिया है: Java 8 Stream and Operation on arrays, और समझें कि इसे दो 1D सरणियों के साथ कैसे करें लेकिन अब आप 2D सरणी की पंक्तियों के माध्यम से कैसे प्रगति करते हैं?

//in this example a[] and b[] are Square matrices
int[] A = [n][n]
int[] B = [n][n]

int[] result = new int[A.length][A[0].length];

//I know this only adds the first rows together.
//How do I now iterate through the rows to sum the entire matrix elementwise
result[0] = IntStream.range(0, A.length).map(i -> A[0][i] + B[0][i]).toArray();

मुझे यह जोड़ना चाहिए कि अंतिम लक्ष्य थ्रेडसेफ समांतर धारा कार्यान्वयन करना है।

0
Jeff O 15 अक्टूबर 2020, 22:59

2 जवाब

सबसे बढ़िया उत्तर

इसे इस तरह करें: यह एक ही संरचना के किन्हीं दो इंट सरणियों पर काम करेगा। मूल रूप से मैं केवल सरणी की लंबाई को पुन: सक्रिय करता हूं, अलग-अलग कोशिकाओं को जोड़ता हूं, और पहले एक सरणी में परिवर्तित करता हूं और फिर उन्हें 2 डी सरणी में परिवर्तित करता हूं।

  • MapToObj आवश्यक है क्योंकि दूसरा इंटस्ट्रीम एक इंट नहीं बल्कि एक स्ट्रीम ऑब्जेक्ट है।

  • तो मुझे बस एक map चाहिए क्योंकि मैं दूसरे IntStream पर अभिनय कर रहा हूं जो ints हैं।

  • ये सभी केवल सूचकांक हैं जिनका उपयोग सरणी मान प्राप्त करने के लिए किया जाता है।

int[][] a = { { 1, 2 }, { 3, 4, 5 }, {3} };
int[][] b = { { 5, 6 }, { 7, 8, 10 }, {4} };

int[][] sum = IntStream.range(0, a.length)
        .mapToObj(r -> IntStream.range(0, a[r].length)
                .map(c -> a[r][c] + b[r][c]).toArray())
        .toArray(int[][]::new);

System.out.println(Arrays.deepToString(sum));

प्रिंटों

[[6, 8], [10, 12, 15], [7]]
0
WJS 16 अक्टूबर 2020, 00:08

आप तत्व-वार योग विभिन्न आकारों के कई दांतेदार 2D सरणियों को निम्नानुसार जोड़ सकते हैं:

public static void main(String[] args) {
    int[][] a = {{3, 3, 3}, {3, 3, 3}, {3, 3, 3}};
    int[][] b = {{2}, {2}};
    int[][] c = {{1, 1}, {1, 1}, {1, 1, 1, 1}};

    int[][] s = sumArrays(a, b, c);

    System.out.println(Arrays.deepToString(s));
    // [[6, 4, 3], [6, 4, 3], [4, 4, 4, 1]]
}
public static int[][] sumArrays(int[][]... arrays) {
    return Arrays.stream(arrays)
          // sequential summation of array pairs
          .reduce((arr1, arr2) -> IntStream
              // iterate over the indexes of the rows of the max array
              .range(0, Math.max(arr1.length, arr2.length))
              // summation of two rows
              .mapToObj(i -> {
                  // at least one row should be present
                  if (arr1.length <= i)
                    return arr2[i];
                  else if (arr2.length <= i)
                    return arr1[i];
                  else // both rows are present
                    return IntStream
                      // iterate over the indices of the max row
                      .range(0, Math.max(arr1[i].length, arr2[i].length))
                      // the sum of two elements if present, or 0 otherwise
                      .map(j -> (arr1[i].length <= j ? 0 : arr1[i][j])
                              + (arr2[i].length <= j ? 0 : arr2[i][j]))
                      // cumulative row
                      .toArray();
              }) // cumulative array
              .toArray(int[][]::new))
          // or an empty array otherwise
          .orElse(new int[0][]);
}

यह भी देखें: 2 अलग-अलग 2D सरणियों का योग

0
14 जून 2021, 01:58