Agfdhyk

I want to get the left and right diagonals of a matrix containing the element with the given column and row indexes.

For example:

rightDiagonal([[1,2,3],[4,5,6],[7,8,9]], 1, 0, Diagonal).

Diagonal = [2,4]



leftDiagonal([[1,2,3],[4,5,6],[7,8,9]], 1, 0, Diagonal).

Diagonal = [4,8]

Thank you.

This is my try:

left_diagonal_left(Board, 0, Column_Index, List, New_List) :-

    get_value_from_matrix(Board, Row_Index, Column_Index, Value),

    append(List, Value, New_List).



left_diagonal_left(Board, Row_Index, 0, List, New_List) :-

    get_value_from_matrix(Board, Row_Index, Column_Index, Value),

    append(List, Value, New_List).



left_diagonal_left(Board, Row_Index, Column_Index, List, New_List) :-

    get_value_from_matrix(Board, Row_Index, Column_Index, Value),

    append(List, Value, New_List),

    R = Row_Index - 1,

    C = Column_Index - 1,

    left_diagonal_left(Board, R, C, New_List, Newer_List).



left_diagonal_right(Board, 6, Column_Index, List, New_List).

left_diagonal_right(Board, Row_Index, 6, List, New_List).   



left_diagonal_right(Board, Row_Index, Column_Index, List, New_List)  :-

    get_value_from_matrix(Board, Row_Index, Column_Index, Value),

    append(List, Value, New_List),

    R = Row_Index + 1,

    C = Column_Index + 1,

    left_diagonal_right(Board, R, C, New_List, Newer_List).



left_diagonal(Board, Row_Index, Column_Index, List, Newer_List) :-

    left_diagonal_left(Board, Row_Index, Column_Index, List, New_List),

    R = Row_Index + 1,

    C = Column_Index + 1,

    left_diagonal_right(Board, R, C, New_List, Newer_List). 

The problem is that the append() fails.

We can make a generic predicate that can walk in both directions (to the left, and to the right).

We basically here need two parameters: the index of the first column, and and the "direction" in which we walk, this is -1 for "right", and 1 for "left".

We can thus implement a predicate diagonal/4 that will generate such diagional.

Basically there are three cases we need to take into account:

1. the matrix has "no rows", in that case the diagonal is an empty list;


2. the matrix has at least one row, but the index is too low/high, in that case the diagonal is an empty list as well; and


3. the matrix has at least one row, and the index is not out of range, in that case we add the element of the first row for the given column, and recursively call the predicate where we shift the column one to the right, or one to the left.

So we can implement this with:

diagonal(, _, _, ).

diagonal([Row|Rest], Col, DCol, Result) :-

    (  nth0(Col, Row, El)

    -> (Result = [El | R2],

        Col2 is Col + DCol,

        diagonal(Rest, Col2, DCol, R2))

    ;  Result = ).

So now we can obtain diagonals with:

?- diagonal([[4,5,6],[7,8,9]], 1, -1, Diagonal).

Diagonal = [5, 7].



?- diagonal([[1,2,3],[4,5,6],[7,8,9]], 1, -1, Diagonal).

Diagonal = [2, 4].



?- diagonal([[4,5,6],[7,8,9]], 0, 1, Diagonal).

Diagonal = [4, 8].

Of course the above is not yet complete: since in the question, one enters two coordinates. In case we take the right coordinate however, for a coordinate pair (X, Y), this is equivalent to (X+Y, 0). The same for left diagonals: the diagonal containing (X, Y) is the same as the one containing (0, Y-X). Note however that it is possible that X+Y, or Y-X are out of range, so we can first "normalize" the coordinate, but in case the coordinate is "too high", or "too low", we thus will need a to drop a certain number of rows, and each time updating the number until we reach a value that is in range.

So we can implement a predicate that first makes some iterations until it finds a valid index, and then passes control to the diagonal/4 predicate, for example prediagonal/4:

prediagonal(, _, _, ).

prediagonal([Row|Rest], Col, DCol, Result) :-

        Col2 is Col + DCol,

        (  nth0(Col, Row, El)

        -> (Result = [El | R2],

            diagonal(Rest, Col2, DCol, R2))

        ;  prediagonal(Rest, Col2, DCol, Result)).

So now we can write our left_diagonal/4 and right_diagonal in terms of prediagonal/4:

left_diagonal(M, R, C, Diagonal) :-

    Delta is C-R,

    prediagonal(M, Delta, 1, Diagonal).



right_diagonal(M, R, C, Diagonal) :-

    Delta is R+C,

    prediagonal(M, Delta, -1, Diagonal).

this then gives us:

?- right_diagonal([[1,2,3],[4,5,6],[7,8,9]], 1, 0, Diagonal).

Diagonal = [2, 4].



?- left_diagonal([[1,2,3],[4,5,6],[7,8,9]], 1, 0, Diagonal).

Diagonal = [4, 8].

The above is not the most elegant solution. It might be better to "merge" diagonal/4 and prediagonal/4 in one predicate. I leave this as an exercise.