[윤용호]

3번 문제는 좋은 테스트셋 만들기가 쉽지 않네요.


1번

# let ae1=Sum[Times[Var"a";Power("x",2)];Times[Var"b";Var"x"];Var"c"];;
val ae1 : ae =
Sum [Times [Var "a"; Power ("x", 2)]; Times [Var "b"; Var "x"]; Var "c"]

# diff (ae1, "x") ;;
- : ae = Sum [Times [Var "a"; Const 2; Power ("x", 1)]; Var "b"]

# diff (ae1, "a") ;;
- : ae = Times [Power ("x", 2)]

# diff (ae1, "b") ;;
- : ae = Times [Var "x"]

# diff (ae1, "c") ;;
- : ae = Const 1

# diff (ae1, "y") ;;
- : ae = Const 0

# let ae2=Sum[Times[Power("x", 3);Power("y",2)];Times[Const 5;Power("x",2);Power("y",4)];Times[Const 2;Power("x",3);Power("y",3);Power("z",3)];Times[Var "x";Power("y",5);Power("z",2)]];;
val ae2 : ae =
　Sum
　　[Times [Power ("x", 3); Power ("y", 2)];
　　Times [Const 5; Power ("x", 2); Power ("y", 4)];
　　Times [Const 2; Power ("x", 3); Power ("y", 3); Power ("z", 3)];
　　Times [Var "x"; Power ("y", 5); Power ("z", 2)]]

# diff (ae2, "x") ;;
- : ae =
Sum
　[Times [Const 3; Power ("x", 2); Power ("y", 2)];
　Times [Const 5; Const 2; Power ("x", 1); Power ("y", 4)];
　Times [Const 2; Const 3; Power ("x", 2); Power ("y", 3); Power ("z", 3)];
　Times [Power ("y", 5); Power ("z", 2)]]

# diff (ae2, "y") ;;
- : ae =
Sum
[Times [Power ("x", 3); Const 2; Power ("y", 1)];
Times [Const 5; Power ("x", 2); Const 4; Power ("y", 3)];
Times [Const 2; Power ("x", 3); Const 3; Power ("y", 2); Power ("z", 3)];
Times [Var "x"; Const 5; Power ("y", 4); Power ("z", 2)]]

# diff (ae2, "z") ;;
- : ae =
Sum
[Times [Const 2; Power ("x", 3); Power ("y", 3); Const 3; Power ("z", 2)];
Times [Var "x"; Power ("y", 5); Const 2; Power ("z", 1)]]

# diff (ae2, "2") ;;
- : ae = Const 0

# let ae3=Sum[Times[Var "x";Var "y"];Times[Var "y";Var "z"];Times[Var "z";Var "x"]];;
val ae3 : ae =
Sum
[Times [Var "x"; Var "y"]; Times [Var "y"; Var "z"];
Times [Var "z"; Var "x"]]

# diff (ae3, "x") ;;
- : ae = Sum [Times [Var "y"]; Var "z"]

# diff (ae3, "y") ;;
- : ae = Sum [Var "x"; Times [Var "z"]]

# diff (ae3, "z") ;;
- : ae = Sum [Var "y"; Times [Var "x"]]

# diff (ae3, "w") ;;
- : ae = Const 0

# let ae4=Times[Sum[Times[Const 2;Power("x",2)];Var "x";Var "y"];Sum[Times[Const 5;Power("x",2);Var "y"];Power("y",2)]];;
val ae4 : ae =
Times
[Sum [Times [Const 2; Power ("x", 2)]; Var "x"; Var "y"];
Sum [Times [Const 5; Power ("x", 2); Var "y"]; Power ("y", 2)]]

# diff (ae4, "x") ;;
- : ae =
Sum
[Times
[Sum [Times [Const 2; Power ("x", 2)]; Var "x"; Var "y"]; Const 5;
Const 2; Power ("x", 1); Var "y"];
Times
[Sum [Times [Const 2; Const 2; Power ("x", 1)]; Const 1];
Sum [Times [Const 5; Power ("x", 2); Var "y"]; Power ("y", 2)]]]

# diff (ae4, "y") ;;
- : ae =
Sum
[Times
[Sum [Times [Const 2; Power ("x", 2)]; Var "x"; Var "y"];
Sum [Times [Const 5; Power ("x", 2)]; Times [Const 2; Power ("y", 1)]]];
Times [Sum [Times [Const 5; Power ("x", 2); Var "y"]; Power ("y", 2)]]]



############################################
2번

지난번 올린 파서로 각 코드를 파싱하면 인터프리터에 입력한 저 결과가 나옵니다.

코드 (a:=10;b:=5;c:=a/b;d:=a*b;a:=a+b/c;print a,b,c,d;d:=0;print if d then a else b;d:=if a then a else b;print d;a:=e)

# let stm1=Seq [Assign("a",Const 10);Assign("b",Const 5);Assign("c",Binop(Var "a",Div,Var "b"));Assign("d",Binop(Var "a",Times,Var "b"));Assign("a",Binop(Var "a",Plus,Binop(Var "b",Div,Var "c")));Print [Var "a";Var "b";Var "c";Var "d"];Assign("d",Const 0);Print [If(Var "d",Var "a",Var "b")];Assign("d",If(Var "a",Var "a",Var "b"));Print [Var "d"];Assign("a",Var "e")];;
val stm1 : stm =
Seq
[Assign ("a", Const 10); Assign ("b", Const 5);
Assign ("c", Binop (Var "a", Div, Var "b"));
Assign ("d", Binop (Var "a", Times, Var "b"));
Assign ("a", Binop (Var "a", Plus, Binop (Var "b", Div, Var "c")));
Print [Var "a"; Var "b"; Var "c"; Var "d"]; Assign ("d", Const 0);
Print [If (Var "d", Var "a", Var "b")];
Assign ("d", If (Var "a", Var "a", Var "b")); Print [Var "d"];
Assign ("a", Var "e")]

# intp (stm1, empty_store) ;;
12,5,2,50
5
12
Exception: Not_found.

# intp (stm1, [("e", 0)]) ;;
12,5,2,50
5
12
- : (id * int) list = [("e", 0); ("a", 0); ("b", 5); ("c", 2); ("d", 12)]

코드 (a:=1;b:=2;print (a+b);print a,b;c:=3;a:=a+b+c;d:=0;print if d then a else b;print if a then a else b;print a,b,c;a:=a+b*c;print a;d:=if d then a else b;print d)

# let stm2=Seq [Assign("a",Const 1);Assign("b",Const 2);Print [Binop(Var "a",Plus,Var "b")];Print [Var "a";Var "b"];Assign("c",Const 3);Assign("a",Binop(Binop(Var "a",Plus,Var "b"),Plus,Var "c"));Assign("d",Const 0);Print [If(Var "d",Var "a",Var "b")];Print [If(Var "a",Var "a",Var "b")];Print [Var "a";Var "b";Var "c"];Assign("a",Binop(Var "a",Plus,Binop(Var "b",Times,Var "c")));Print [Var "a"];Assign("d",If(Var "d",Var "a",Var "b"));Print [Var "d"]];;
val stm2 : stm =
Seq
[Assign ("a", Const 1); Assign ("b", Const 2);
Print [Binop (Var "a", Plus, Var "b")]; Print [Var "a"; Var "b"];
Assign ("c", Const 3);
Assign ("a", Binop (Binop (Var "a", Plus, Var "b"), Plus, Var "c"));
Assign ("d", Const 0); Print [If (Var "d", Var "a", Var "b")];
Print [If (Var "a", Var "a", Var "b")];
Print [Var "a"; Var "b"; Var "c"];
Assign ("a", Binop (Var "a", Plus, Binop (Var "b", Times, Var "c")));
Print [Var "a"]; Assign ("d", If (Var "d", Var "a", Var "b"));
Print [Var "d"]]

# intp (stm2, empty_store) ;;
3
1,2
2
6
6,2,3
12
2
- : (id * int) list = [("a", 12); ("b", 2); ("c", 3); ("d", 2)]

############################################
3번

(* 샘만 많은 조카들 *)
# let req1=[(A, [Same B]);(B, [Same A]);(C, [Same B]);(D, [Same C]);(E, [Same D])];;
val req1 : (id * cond list) list =
[(A, [Same B]); (B, [Same A]); (C, [Same B]); (D, [Same C]); (E, [Same D])]

# shoppingList req1 ;;
- : (id * gift list) list = [(A, []); (B, []); (C, []); (D, []); (E, [])]

(* 까다로운 조카들 *)
# let req2=[(A, [Except (Same B, [1])]);(B, [Except (Same A, [2])]);(C, [Except (Same B, [3])]);(D, [Except (Same A, [4])]);(E, [Except (Same D, [4])])];;
val req2 : (id * cond list) list =
[(A, [Except (Same B, [1])]); (B, [Except (Same A, [2])]);
(C, [Except (Same B, [3])]); (D, [Except (Same A, [4])]);
(E, [Except (Same D, [4])])]

# shoppingList req2 ;;
- : (id * gift list) list = [(A, []); (B, []); (C, []); (D, []); (E, [])]

(* 탐욕스런 조카들 *)
# let req3=[(A, [Same B;Same C;Same D;Same E]);(B, [Same A;Same C;Same D;Same E]);(C, [Same A;Same B;Same D;Same E]);(D, [Same A;Same B;Same C;Same E]);(E, [Same A;Same B;Same C;Same D])];;
val req3 : (id * cond list) list =
[(A, [Same B; Same C; Same D; Same E]);
(B, [Same A; Same C; Same D; Same E]);
(C, [Same A; Same B; Same D; Same E]);
(D, [Same A; Same B; Same C; Same E]);
(E, [Same A; Same B; Same C; Same D])]

# shoppingList req3;;
- : (id * gift list) list = [(A, []); (B, []); (C, []); (D, []); (E, [])]

(* 샘이 없는 조카들 *)
# let req4=[(A, [Items [1]]);(B, [Items [2]]);(C, [Items [3]]);(D, [Items [4]]);(E, [Items [5]])];;
val req4 : (id * cond list) list =
[(A, [Items [1]]); (B, [Items [2]]); (C, [Items [3]]); (D, [Items [4]]);
(E, [Items [5]])]

# shoppingList req4 ;;
- : (id * gift list) list =
[(A, [1]); (B, [2]); (C, [3]); (D, [4]); (E, [5])]

# let sample_req=[(A, [Items [1; 2]; Common (Same B, Same C)]);(B, [Common (Same C, Items [2; 3])]);(C, [Items [1]; Except (Same A, [3])])];;
val sample_req : (id * cond list) list =
[(A, [Items [1; 2]; Common (Same B, Same C)]);
(B, [Common (Same C, Items [2; 3])]);
(C, [Items [1]; Except (Same A, [3])])]

# shoppingList sample_req ;;
- : (id * gift list) list =
[(A, [1; 2]); (B, [2]); (C, [1; 2]); (D, []); (E, [])]

A : 최소한 {1,2} 하고 B하고 C는 받아야
B : 최소한 common(C, {2,3})하고 A는 받아야
C : 최소한 {1}하고 (B except {2})를 받아야
D : 최소한 {2,3}하고 common(A,B)를 받아야
E : 최소한 {2}하고 (A except {3})을 받아야

# let req5=[(A, [Items [1;2];Same B;Same C]);(B, [Common(Same C, Items [2;3]);Same A]);(C, [Items[1];Except (Same B, [2])]);(D, [Items[2;3];Common(Same A, Same B)]);(E, [Items[2];Except(Same A, [3])])];;
val req5 : (id * cond list) list =
[(A, [Items [1; 2]; Same B; Same C]);
(B, [Common (Same C, Items [2; 3]); Same A]);
(C, [Items [1]; Except (Same B, [2])]);
(D, [Items [2; 3]; Common (Same A, Same B)]);
(E, [Items [2]; Except (Same A, [3])])]

# shoppingList req5 ;;
- : (id * gift list) list =
[(A, [1; 2]); (B, [1; 2]); (C, [1]); (D, [1; 2; 3]); (E, [1; 2])]

A : 최소한 {1,2} 하고 B하고 C는 받아야
B : 최소한 common(C, {2,3})하고 A는 받아야
C : 최소한 {1,2,3,4}하고 (B except {2})를 받아야
D : 최소한 {2,3}하고 common(A,B)를 받아야
E : 최소한 {2}하고 (A except {3})을 받아야

# let req6=[(A, [Items [1;2];Same B;Same C]);(B, [Common(Same C, Items [2;3]);Same A]);(C, [Items[1;2;3;4];Except (Same B, [2])]);(D, [Items[2;3];Common(Same A, Same B)]);(E, [Items[2];Except(Same A, [3])])];;
val req6 : (id * cond list) list =
[(A, [Items [1; 2]; Same B; Same C]);
(B, [Common (Same C, Items [2; 3]); Same A]);
(C, [Items [1; 2; 3; 4]; Except (Same B, [2])]);
(D, [Items [2; 3]; Common (Same A, Same B)]);
(E, [Items [2]; Except (Same A, [3])])]

# shoppingList req6 ;;
- : (id * gift list) list =
[(A, [1; 2; 3; 4]); (B, [1; 2; 3; 4]); (C, [1; 2; 3; 4]); (D, [1; 2; 3; 4]);
(E, [1; 2; 4])]

A : 최소한 {1,2} 하고 B Except {4}는 받아야
B : 최소한 {2,3} 하고 C Except {5}은 받아야
C: 최소한 {3,4} 하고 D Except {1}는 받아야
D : 최소한 {4,5} 하고 E Except {2}는 받아야
E : 최소한 {5,6} 하고 A Except {3}은 받아야

# let req7=[(A, [Items[1;2];Except(Same B, [4])]);(B, [Items[2;3];Except(Same C, [5])]);(C, [Items[3;4];Except(Same D, [1])]);(D, [Items[4;5];Except(Same E, [2])]);(E, [Items[5;6];Except(Same A, [3])])];;
val req7 : (id * cond list) list =
[(A, [Items [1; 2]; Except (Same B, [4])]);
(B, [Items [2; 3]; Except (Same C, [5])]);
(C, [Items [3; 4]; Except (Same D, [1])]);
(D, [Items [4; 5]; Except (Same E, [2])]);
(E, [Items [5; 6]; Except (Same A, [3])])]

# shoppingList req7 ;;
- : (id * gift list) list =
[(A, [1; 2; 3; 6]); (B, [2; 3; 4; 6]); (C, [3; 4; 5; 6]); (D, [1; 4; 5; 6]);
(E, [1; 2; 5; 6])]

A : 최소한 {1,2,3} 하고 Common(B,C) Except {4}을 받아야
B : 최소한 {2,3,4} 하고 Common(C,D) Except {5}를 받아야
C : 최소한 {3,4,5} 하고 Common(A,E) Except {1}을 받아야
D : 최소한 {1,4,5} 하고 Common(B,E) Except {3}를 받아야
E : 최소한 {1,3,5} 하고 Common(A,B) Except {2,4}을 받아야

# let req8=[(A, [Items[1;2;3];Except(Common(Same B, Same C), [4])]);(B, [Items[2;3;4];Except(Common(Same C, Same D), [5])]);(C, [Items[3;4;5];Except(Common(Same A, Same E), [1])]);(D, [Items[1;4;5];Except(Common(Same B, Same E), [3])]);(E, [Items[1;3;5];Except(Common(Same A, Same B), [2;4])])];;
val req8 : (id * cond list) list =
[(A, [Items [1; 2; 3]; Except (Common (Same B, Same C), [4])]);
(B, [Items [2; 3; 4]; Except (Common (Same C, Same D), [5])]);
(C, [Items [3; 4; 5]; Except (Common (Same A, Same E), [1])]);
(D, [Items [1; 4; 5]; Except (Common (Same B, Same E), [3])]);
(E, [Items [1; 3; 5]; Except (Common (Same A, Same B), [2; 4])])]

# shoppingList req8;;
- : (id * gift list) list =
[(A, [1; 2; 3]); (B, [2; 3; 4]); (C, [3; 4; 5]); (D, [1; 4; 5]);
(E, [1; 3; 5])]

A : 최소한 {1,2} 하고 Common(B, {3,4,5})을 받아야
B : 최소한 {3} 하고 D Except {1,4}을 받아야
C : 최소한 {4} 하고 Common(A, D)를 받아야
D : 최소한 {4,5} 하고 A를 받아야
E : 최소한 {1,3,5} 하고 B 하고 D Except {5}를 받아야

# let req9=[(A, [Items[1;2];Common(Same B, Items[3;4;5])]);(B, [Items[3];Except(Same D, [1;4])]);(C, [Items[4];Common(Same A, Same D)]);(D, [Items[4;5];Same A]);(E, [Items[1;3;5];Same B;Except(Same D, [5])])];;
val req9 : (id * cond list) list =
[(A, [Items [1; 2]; Common (Same B, Items [3; 4; 5])]);
(B, [Items [3]; Except (Same D, [1; 4])]);
(C, [Items [4]; Common (Same A, Same D)]); (D, [Items [4; 5]; Same A]);
(E, [Items [1; 3; 5]; Same B; Except (Same D, [5])])]

# shoppingList req9;;
- : (id * gift list) list =
[(A, [1; 2; 3; 5]); (B, [2; 3; 5]); (C, [1; 2; 3; 4; 5]);
(D, [1; 2; 3; 4; 5]); (E, [1; 2; 3; 4; 5])]

A : 최소한 {1,2} 하고 Common(B, {3})을 받아야
B : 최소한 {4} 하고 D Except {1,4}를 받아야
C : 최소한 {4} 하고 Common(A,D)를 받아야
D : 최소한 {3,5} 하고 A를 받아야
E : 최소한 {2,5} 하고 C 하고 D Except {3,4}를 받아야

# let req10=[(A, [Items[1;2];Common(Same B, Items[3])]);(B, [Items[4];Except(Same D, [1;4])]);(C, [Items[4];Common(Same A, Same D)]);(D, [Items[3;5];Same A]);(E, [Items[2;5];Same C;Except (Same D, [3;4])])];;
val req10 : (id * cond list) list =
[(A, [Items [1; 2]; Common (Same B, Items [3])]);
(B, [Items [4]; Except (Same D, [1; 4])]);
(C, [Items [4]; Common (Same A, Same D)]); (D, [Items [3; 5]; Same A]);
(E, [Items [2; 5]; Same C; Except (Same D, [3; 4])])]

# shoppingList req10 ;;
- : (id * gift list) list =
[(A, [1; 2; 3]); (B, [2; 3; 4; 5]); (C, [1; 2; 3; 4]); (D, [1; 2; 3; 5]);
(E, [1; 2; 3; 4; 5])]
_________________
TA

[강동옥]

let req = [(A, [Items[1;2;5;6];Common(Common (Same B, Same E), Items[1;5])]);(B, [Items[3;4;5;6];Except(Same D, [2;4])]);(C, [Items[4;6];Common(Same A, Same D)]);(D, [Items[3;5];Except (Common (Same A, Same B), [5;6])]);(E, [Items[2;5;7];Same C;Except (Same D, [3;4])])];;
val req : (id * cond list) list =
[(A, [Items [1; 2; 5; 6]; Common (Common (Same B, Same E), Items [1; 5])]);
(B, [Items [3; 4; 5; 6]; Except (Same D, [2; 4])]);
(C, [Items [4; 6]; Common (Same A, Same D)]);
(D, [Items [3; 5]; Except (Common (Same A, Same B), [5; 6])]);
(E, [Items [2; 5; 7]; Same C; Except (Same D, [3; 4])])]

# shoppingList req;;
- : (id * gift list) list =
[(A, [1; 2; 5; 6]); (B, [3; 4; 5; 6]); (C, [4; 5; 6]); (D, [3; 5]);
(E, [2; 4; 5; 6; 7])]

# let req = [(A, [Items[1;2;5;6];Common(Common (Same B, Same E), Items[1;5])]);(B, [Items[3;4;5;6];Except(Same D, [2;4])]);(C, [Items[4;6];Common(Same A, Same D)]);(D, [Items[3];Except (Common (Except (Common (Same A, Items [1;2;3;5;6;7]), [2]), Same B), [5;6])]);(E, [Items[2;5;7];Same C;Except (Same D, [3;4])])];;
val req : (id * cond list) list =
[(A, [Items [1; 2; 5; 6]; Common (Common (Same B, Same E), Items [1; 5])]);
(B, [Items [3; 4; 5; 6]; Except (Same D, [2; 4])]);
(C, [Items [4; 6]; Common (Same A, Same D)]);
(D,
[Items [3];
Except
(Common (Except (Common (Same A, Items [1; 2; 3; 5; 6; 7]), [2]),
Same B),
[5; 6])]);
(E, [Items [2; 5; 7]; Same C; Except (Same D, [3; 4])])]
# shoppingList req;;
- : (id * gift list) list =
[(A, [1; 2; 5; 6]); (B, [3; 4; 5; 6]); (C, [4; 6]); (D, [3]);
(E, [2; 4; 5; 6; 7])]

# let req = [(A, [Items[1;2];Except (Common (Same B, Same E), [1;5;6])]);(B, [Items[3;4;5;6];Except(Same A, [2;4])]);(C, [Items[4;6];Common(Same A, Same E)]);(D, [Items[3];Except (Common (Except (Common (Same A, Items [1;2;3;5;6;7]), [2]), Same B), [5;6])]);(E, [Items[2;5;7];Same C;Except (Same D, [3;4])])];;
val req : (id * cond list) list =
[(A, [Items [1; 2]; Except (Common (Same B, Same E), [1; 5; 6])]);
(B, [Items [3; 4; 5; 6]; Except (Same A, [2; 4])]);
(C, [Items [4; 6]; Common (Same A, Same E)]);
(D,
[Items [3];
Except
(Common (Except (Common (Same A, Items [1; 2; 3; 5; 6; 7]), [2]),
Same B),
[5; 6])]);
(E, [Items [2; 5; 7]; Same C; Except (Same D, [3; 4])])]
# shoppingList req;;
- : (id * gift list) list =
[(A, [1; 2; 4]); (B, [1; 3; 4; 5; 6]); (C, [1; 2; 4; 6]); (D, [1; 3]);
(E, [1; 2; 4; 5; 6; 7])]