用prolog表示n次

我期望的结果是

  matrix_add([[0,0,1],[0,1,1],[1,1,1]],[[1,0,0],[1,1,0],[1,1,1]]).

这一个在n度是可能的

例如，

matrix_add（[0,1]，[2,3]，[2,1]，[6,4]）。

是可能的

 matrix A is [0,0,1],[0,1,1],[1,1,1]
 matrix B is [1,0,0],[1,1,0],[1,1,1]
 sum is [1,0,1],[1,2,1],[2,2,2]

//但它不起作用

 matrix_add([],[],[]).
 matrix_add(M1,M2,Result):-

        nl,
        write('matrix A is'),
        nl,
        writeln(M1), 

你能告诉我如何显示这个数组吗

===================================================

        nl,
        write('matrix B is'),
        nl,
        writeln(M2),
        Result is (M1 + M2),
        nl,

        nl,
        write('sum is'),
        nl,
        writeln(Result).

我希望结果是这样的

  matrix_add([M1|M1s],[M2|M2s]):-
       write('==============='),
       nl,
       write('Matrix A is'),
       nl,
       write(M1),
       write(M1s),
       nl,
       write('==============='),
       nl,
       write('Matrix B is'),
       nl,
       write(M2),
       writeln(M2s),
       nl,
       matrix_add_aux(M1,M2,[R|Rs]),
       write('==============='),
       nl,
       write('Sum is'),
       nl,
       writeln(R),
       writeln(Rs).

---

这与您的尝试相匹配：

  matrix A is 
  [0,0,1]
  [0,1,1]
  [1,1,1]
  ...

---

吉列尔莫的回答是正确的，但这里有更多关于到达那里的过程的解释

使用内置的

maplist

，有一种非常简单的方法可以做到这一点。但是为了学习如何在Prolog中处理列表，因为这是一项作业，这里有一些关于如何处理问题的提示

二维矩阵是一维数组（或向量）的一维数组（或向量）。数组是一个有序的值序列，这正是Prolog中的列表。因此，数组可以方便地用列表表示。如示例输入矩阵所示：

第一个矩阵：

[[0,0,1]，[0,1,1]，[1,1,1]]

在这个矩阵中，第一行是

[0,0,1]

，第二行是

[0,1,1]

，第三行是

[1,1,1]

要添加两个矩阵，需要将每一行作为一个数组进行遍历，然后将数组添加到一起。如何添加两个数组？相同的过程：遍历每个元素并将元素添加到一起。所以你知道你的解决方案是这样的

在Prolog中，您知道（希望如此）表单

[H | T]

代表一个列表，并给出列表的第一个元素

H

，以及列表的其余部分

T

。例如，如果您有：

%initial call
matrix_add(M1,M2):-
    write('Matrix A is'),
    writeln(M1),
    write('Matrix B is'),
    writeln(M2),
    matrix_add_aux(M1,M2,Result),
    write('Sum is'),
    writeln(Result).

%now check rows one by one

%base case
matrix_add_aux([],[],[]).

%recursive case
matrix_add_aux([X|Xs],[Y|Ys],[R|Rs]):-
    matrix_add_row(X,Y,R),
    matrix_add_aux(Xs,Ys,Rs).

%and now sum the values in the row

%base case
matrix_add_row([],[],[]).

%recursive case
matrix_add_row([X|Xs],[Y|Ys],[R|Rs]):-
    R is X + Y,
    matrix_add_row(Xs,Ys,Rs).

然后

H=[0,0,1]

和

T=[0,1,1]，[1,1,1]

要解决你的问题，首先，用通俗易懂的语言写出解决方案，这样你就知道你在做什么了。：）

空矩阵加上空矩阵就是空矩阵

现在回到上面提到的关于如何添加两个矩阵的内容，并将矩阵视为一个有头和尾的列表列表：

如果向量

H1

和

H2

的和为

H

且矩阵

T1

和

T2

的和为

T

，则矩阵

H1

和

T2

的和为

T

，则矩阵的和为

这就完成了
矩阵\u add
谓词。现在必须编写
vector\u add
。
vector\u add
谓词看起来就像
matrix\u add
，不同的是，向量中的每个元素都只是一个数字，而不是一个列表，因此您可以直接添加它们并完成操作

运行查询时：

matrix_add([H1|T1], [H2|T2], [H|T]) :-
    vector_add(H1, H2, H),
    matrix_add(T1, T2, T).

Prolog将为您显示答案：

matrix_add([[0,0,1],[0,1,1],[1,1,1]],[[1,0,0],[1,1,0],[1,1,1]], Result).

您可以使用
writeln
进行显示，但这是在Prolog中进行显示的更常见的方法，因为它在参数中提供结果，而不仅仅是将结果写入显示。如果要将其写入显示器，您可以始终将
writeln（[H1 | T1]）
或任何内容放入代码中。

结语

下面是使用
maplist
的简化解决方案：

Result = [[1,0,1],[1,2,1],[2,2,2]]

结果：

matrix_add(M1, M2, Result) :-
    writeln('Matrix A is'),
    write_matrix(M1),
    writeln('Matrix B is'),
    write_matrix(M2),
    maplist(maplist(add), M1, M2, Result),
    writeln('Matrix A+B is'),
    write_matrix(Result).

write_matrix(M) :-
    maplist(writeln, M), nl.

add(X, Y, Z) :- Z is X + Y.

你能试着解决这个问题吗？您只需要将其分解为两层标准列表处理。矩阵加（Cs，Ps）：-nl，write（'matrix 1 is'），nl，writeln（Cs），writeln（Ps），……这并不多，即使加上两个“null”矩阵也是不正确的。它有两个操作数，但没有结果。如果你想在Prolog中说，空矩阵加上空矩阵就是空矩阵，也就是说，
matrix\u add（[]，[]，[]）。
。一般谓词看起来像，
matrix\u add（M1，M2，Result）
，这样谓词就可以提供一个结果。这是课堂作业吗？是的，这是作业。你能告诉我writeln的功能吗？我不知道用双链表来表示矩阵A。我想你不用“链表”，但你已经展示的，例如，
M1
可能是，
[[0,0,1]，[0,1,1]，[1,1,1]
。矩阵是一个“数组数组”（或者在Prolog中，将“数组”表示为列表，列表是元素的有序序列）。在Prolog中，您可以使用
[H | T]
的形式一次处理一个列表元素，
H
是列表的第一个元素，
T
是列表的其余部分。因此，谓词需要依次查看矩阵中的每个数组，并将这些数组相加，以生成结果的数组。结果是这些数组的数组（矩阵）。那么，如何显示这个呢？就像‘矩阵A是[0,0,1]，nl[0,1,1]，nl[1,1,1]。@user3450300在代码示例中显示它是正确的。吉列尔莫在他的正确答案中很好地运用了这一点。只要在需要新行的地方使用
write
或
writeln
和
nl
。例如，
write（'matrix A is'）、write（[H1 | T1]）、nl.
我写了另外一个问题，你能告诉我吗？=============后面是问题。@user3450300创建一个名为
write_matrix（[]）的谓词。编写_矩阵（[H | T]）：-writeln（H），write _矩阵（T）。
并在您想要编写的任何矩阵上调用它。这是一个非常简单的列表处理过程，如果您正在学习Prolog列表处理，那么您可以很容易地确定是否考虑了足够长的时间。这是一个正确的答案（+1）。我继续回答，以帮助解释这个过程。
Result = [[1,0,1],[1,2,1],[2,2,2]]

matrix_add(M1, M2, Result) :-
    writeln('Matrix A is'),
    write_matrix(M1),
    writeln('Matrix B is'),
    write_matrix(M2),
    maplist(maplist(add), M1, M2, Result),
    writeln('Matrix A+B is'),
    write_matrix(Result).

write_matrix(M) :-
    maplist(writeln, M), nl.

add(X, Y, Z) :- Z is X + Y.

?- matrix_add([[0,0,1],[0,1,1],[1,1,1]],[[1,0,0],[1,1,0],[1,1,1]], Result).
Matrix A is
[0,0,1]
[0,1,1]
[1,1,1]

Matrix B is
[1,0,0]
[1,1,0]
[1,1,1]

Matrix A+B is
[1,0,1]
[1,2,1]
[2,2,2]

Result = [[1, 0, 1], [1, 2, 1], [2, 2, 2]].