Competitive Programming Solutions

N. Sum of a Matrix

Codeforces - Sheet #7 (Recursion) · limit: 1s · memory: 256MB · view on codeforces

input

output

2 5 8
11 14 17

Main.java

static void solve() {

        // Write your solution here
        int m = in.nextInt();
        int n = in.nextInt();
        
        int[][] a = new int[m][n];
        int[][] b = new int[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = in.nextInt();
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                b[i][j] = in.nextInt();
            }
        }

        int[][] c = new int[m][n];

        summation(a, b, c, 0, 0); 

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                out.print(c[i][j] + " ");
            }
            out.println();
        }
    }

import java.io.*;
import java.util.*;

public class Main {
    static final int MOD = 1_000_000_007;
    static final int MOD2 = 998_244_353;
    static final Random rnd = new Random();

    static FastReader in = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        int t = 1;
        // Comment if program has single input
        // t = in.nextInt();
        while (t-- > 0) {
            solve();
        }
        out.flush();
    }

    static void solve() {

        // Write your solution here
        int m = in.nextInt();
        int n = in.nextInt();
        
        int[][] a = new int[m][n];
        int[][] b = new int[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = in.nextInt();
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                b[i][j] = in.nextInt();
            }
        }

        int[][] c = new int[m][n];

        summation(a, b, c, 0, 0); 

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                out.print(c[i][j] + " ");
            }
            out.println();
        }
    }

    static void summation(int[][] a, int[][] b, int[][] c, int i, int j){
        if (i == a.length)
        return;

        c[i][j] = a[i][j] + b[i][j];

        if (j == a[0].length - 1)
            summation(a, b, c, i + 1, 0);
        else
            summation(a, b, c, i, j + 1);
    }

    // =========================
    // Array Input
    // =========================

    static int[] readIntArray(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextInt();
        return a;
    }

    static long[] readLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();
        return a;
    }

    // =========================
    // Safe Sort
    // =========================

    static void safeSort(int[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    static void safeSort(long[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    static void shuffle(int[] a) {
        for (int i = a.length - 1; i > 0; i--) {
            int j = rnd.nextInt(i + 1);
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }

    static void shuffle(long[] a) {
        for (int i = a.length - 1; i > 0; i--) {
            int j = rnd.nextInt(i + 1);
            long temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }

    // =========================
    // Math
    // =========================

    static long gcd(long a, long b) {
        while (b != 0) {
            long t = b;
            b = a % b;
            a = t;
        }
        return a;
    }

    static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    static long power(long base, long exp, long mod) {
        long ans = 1;
        base %= mod;

        while (exp > 0) {
            if ((exp & 1) == 1)
                ans = (ans * base) % mod;

            base = (base * base) % mod;
            exp >>= 1;
        }

        return ans;
    }

    // =========================
    // Reverse
    // =========================

    static void reverse(int[] a) {
        int l = 0, r = a.length - 1;
        while (l < r) {
            int temp = a[l];
            a[l++] = a[r];
            a[r--] = temp;
        }
    }

    static void reverse(long[] a) {
        int l = 0, r = a.length - 1;
        while (l < r) {
            long temp = a[l];
            a[l++] = a[r];
            a[r--] = temp;
        }
    }

    // =========================
    // Fast Reader
    // =========================

    static class FastReader {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}