Test results - Codility

Your browser is not supported. Please, update your browser or switch to a different one. Learn more about which browsers are supported.

Tasks Details

hard

1. MaxPathFromTheLeftTopCorner

Find a maximal value path in a matrix, starting in the top-left corner and ending in the bottom-right corner.

Task Score

77%

Correctness

100%

Performance

33%

Task description

You are given a matrix A consisting of N rows and M columns, where each cell contains a digit. Your task is to find a continuous sequence of neighbouring cells, starting in the top-left corner and ending in the bottom-right corner (going only down and right), that creates the biggest possible integer by concatenation of digits on the path. By neighbouring cells we mean cells that have exactly one common side.

Write a function:

class Solution { public String solution(int[][] A); }

that, given matrix A consisting of N rows and M columns, returns a string which represents the sequence of cells that we should pick to obtain the biggest possible integer.

For example, given the following matrix A:

[9 9 7]
[9 7 2]
[6 9 5]
[9 1 2]

the function should return "997952", because you can obtain such a sequence by choosing a path as shown below:

[9 9 *]
[* 7 *]
[* 9 5]
[* * 2]

Write an efficient algorithm for the following assumptions:

N and M are integers within the range [1..1,000];

each element of matrix A is an integer within the range [1..9].

Solution

Programming language used Java 21

Time spent on task 42 minutes

Notes

not defined yet

Task timeline

‌

Code: 17:02:33 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
    }
}

Code: 17:28:28 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
    }
}
 public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }

Code: 17:28:39 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Code: 17:28:50 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff()
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Code: 17:29:22 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A)
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Code: 17:29:32 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,)
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Code: 17:29:42 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.le)
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Code: 17:30:06 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.le,A[0].length)
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Code: 17:30:12 UTC, java, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length)
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Analysis

Compile error

Solution.java:10: error: ';' expected
        return ff(A,0,0,A.length,A[0].length)
                                             ^
1 error

Code: 17:30:24 UTC, java, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
     public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }

        }
    }
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.004 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	at Solution.ff(Solution.java:17)
	at Solution.ff(Solution.java:18)
	at Solution.ff(Solution.java:20)
	at Solution.ff(Solution.java:18)
	at Solution.ff(Solution.java:22)
	at Solution.solution(Solution.java:10)
	at Exec.run(exec.java:48)
	at Exec.main(exec.java:34)

Code: 17:33:27 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
}

Code: 17:33:39 UTC, java, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
}

Analysis

Compile error

Solution.java:34: error: reached end of file while parsing
}
 ^
1 error

Code: 17:33:57 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
}
}

Code: 17:33:57 UTC, java, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 || A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 || A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
}
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.004 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	at Solution.ff(Solution.java:17)
	at Solution.ff(Solution.java:18)
	at Solution.ff(Solution.java:20)
	at Solution.ff(Solution.java:18)
	at Solution.ff(Solution.java:22)
	at Solution.solution(Solution.java:10)
	at Exec.run(exec.java:48)
	at Exec.main(exec.java:34)

Code: 17:41:49 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else if (A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
    }
}

Code: 17:41:51 UTC, java, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else if (A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

Code: 17:44:10 UTC, java, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else if (A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

Code: 17:44:14 UTC, java, final, score: 77

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public String solution(int[][] A) {
        // write your code in Java SE 8
        return ff(A,0,0,A.length,A[0].length);
    }
      public String ff(int A[][], int i, int j, int n, int m) {
        if (i >= n || j >= m) {
            return "";
        } else if (i == n - 1 && j == m - 1) {
            return String.valueOf(A[i][j]);
        } else if (i == n - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (j == m - 1 ) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else if (A[i][j + 1] > A[i + 1][j]) {
            return String.valueOf(A[i][j]) + ff(A, i, j + 1, n, m);
        } else if (A[i + 1][j] > A[i][j + 1]) {
            return String.valueOf(A[i][j]) + ff(A, i + 1, j, n, m);
        } else {
            String p1 = ff(A, i + 1, j, n, m);
            String p2 = ff(A, i, j + 1, n, m);
            if (p1.length() > p2.length()) {
                return String.valueOf(A[i][j]) + p1;
            } else if (p2.length() > p1.length()) {
                return String.valueOf(A[i][j]) + p2;
            } else if (p1.compareTo(p2) < 0) {
                return String.valueOf(A[i][j]) + p2;
            } else {
                return String.valueOf(A[i][j]) + p1;
            }
        }
    }
}

Analysis summary

The following issues have been detected: timeout errors.

Analysis

Detected time complexity:

O(2**(N+M)) or O(N*M*(N+M))

expand all Example tests

▶

example
example test

✔

0.008 s

expand all Correctness tests

▶

simple
simple tests with N <= 3 and M <= 3

✔

0.004 s

0.008 s

▶

small_array
tests with N = 1 and M = 1

✔

0.008 s

0.004 s

▶

one_row
tests with N = 1

✔

0.008 s

0.004 s

▶

one_column
tests with M = 1

✔

0.008 s

0.004 s

0.008 s

▶

same_values
all elements from the matrix have the same value

✔

0.012 s

0.008 s

0.496 s

▶

same_values_except_one
all elements except one are the same

✔

0.004 s

0.044 s

expand all Performance tests

▶

random_small_tests
small random tests

✔

0.004 s

0.008 s

▶

big_values
all elements are either 8 or 9

✘

TIMEOUT ERROR
Killed. Hard limit reached: 15.000 sec.

15.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 15.000 sec.

0.012 s

6.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 6.000 sec.

▶

big_matrix_size

✘

TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.

6.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 6.000 sec.

15.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 15.000 sec.

11.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 11.000 sec.