* Login   * Register


Last visit was:
It is currently Sat Feb 24, 2018 3:08 am
View unanswered posts
View active topics





Post new topic Reply to topic  [ 2 posts ] 
Author Message
 Post subject: Bài Tập Lập trình
PostPosted: Wed Jun 10, 2009 12:11 am 
Offline
User avatar

Joined: Thu Feb 05, 2009 4:08 pm
Posts: 11
---------
Bài 1: Viết hàm phát sinh danh sách L ngẫu nhiên 100 phần tử thuộc khoảng [10,100]
a) Sử dụng thuật toán sắp xếp mà bạn biết. Viết Module sắp xếp L
b) Tìm những số nguyên tố trong L >30 và <60
c) Chia danh sách thành L1 (50 phần tử đầu) L2 (50 phần tử cuối). Sau đó trộn 2 danh sách lại với nhau theo thứ tự xen kẻ.
d) Tính tổng các phần tử chẳn trong L
e) Tìm các phần tử thuộc 2 danh sách L1 và L2
f) Ghép L lại thành một chuổi số

L=Table[Random[Integer,{10,100}],{100}]
(* Cau a: sap xep danh sach theo chieu tang dan *)
SapXepTang[L]:=Module[{i,j,tam},
For[i=1,i<Length[L],++i,
For[j=i+1,j<=Length[L],++j,
If[L[[i]]>L[[j]],
tam=L[[i]];
L[[i]]=L[[j]];
L[[j]]=tam;
]
]
]
Print[L]
]
SapXepTang[L]
(* Cau b: Tim so nguyen to trong danh sach lon hon >30 va nho hon <60*)
TimSoNguyenTo[L]:=Module[{dsnguyento},
dsnguyento={};
For[i=1,iLength[L],++i,
If[PrimeQ[L[[i]]] && L[[i]]>30 && L[[i]]<60,AppendTo[dsnguyento,L[[i]]]
]
]
Print[dsnguyento]
]
TimSoNguyenTo[L]
(* cau c: Chia L thanh L1 ( 50 phan tu dau), L2 (50 phan tu cuoi)sau do tron 2 ds lai voi nhau theo thu tuxen ke *)
L1=Take[L,Ceiling[Length[L]/2]]
L2=Take[L,-Floor[Length[L]/2]]
Tron2ds[L1,L2]:=Module[{dsmoi,i},
dsmoi={};

Print[dsmoi];
]
Tron2ds[L1,L2]
(* Tinh tong cac phan tu chan trong L *)

TinhTong[L]:=Module[{tong,i},
tong=0;
For[i=1,iLength[L],++i,
If[Mod[L[[i]],2]0,tong+=L[[i]]
]
]
Print[tong];
]
TinhTong[L]
(* tim cac phan tu thuoc 2 danh sach l1 va L2*)
Intersection[L1,L2]

(*Ghep chuoi*)
Ghepchuoi[L]:=Module[{i,chuoi},
chuoi="";
For[i=1,iLength[L],++i,chuoi=chuoi<>ToString[L[[i]]]];
Return [chuoi];
]
Print["Ket qua: ", Ghepchuoi[L]]

Bài 2: Tạo ra một danh sách các số nguyên ngẫu nhiên thuộc [20,120] gồm n phần tử (n>0), n nhập từ bàn phím.
a. In ra phần tử đầu, giữa và cuối DS.
b. Sắp xếp DS theo chiều tăng giảm theo.
c. Chia DS ra thành hai DS mới và trộn các phần tử trong hai mới DS này xen kẻ với nhau thành 1 danh sách mới có n phần tử.
Ví dụ: Ds = {2,7,8,3,11,6,7}->{2,7,8,3},{11,6,7}
->{2,11,7,6,8,7,3}
d. Tính tổng các phần tử trong DS.
e. Tìm tất cả các phần tử trong danh sách lớn hơn 50 và nhỏ hơn 70 lưu vào trong 1 DS mới.
f. Tìm trong DS tất cả các số nguyên tố.
g. Chia DS thành hai DS mới theo DS số chẵn và DS số lẻ.
h. Ví dụ: Ds = {2,7,8,3,11,6,7}->{2,8,6},{7,3,11,7}


ds = Table[Random[Integer,{20,230}],{30}]

(* Cau a:*)

Print["Phan tu dau: ",First[ds]];
Print["Phan tu cuoi: ",Last[ds]];
Print["Phan tu giua: ",ds[[Length[ds]/2]]];

(* Cau b*)

Sort[ds]
Sort[ds,Greater]

(* Cau c*)

ds1=Take[ds,Ceiling[Length[ds]/2]]
ds2=Take[ds,-Floor[Length[ds]/2]]
i=1;
dsmoi={};
While[iLength[ds1],
AppendTo[dsmoi,ds1[[i]]];
AppendTo[dsmoi,ds2[[i]]];
i++;
]
Print[dsmoi]

(* Cau d *)

Sum[ds[[i]],{i,Length[ds]}]

(* Cau e *)

TimPhanTu[ds]:=Module[{dsptmoi,i},
dsptmoi={};
For[i=1,iLength[ds],i++,
If[ds[[i]] 50 && ds[[i]]70,
dsptmoi=AppendTo[dsptmoi,ds[[i]]]
]
]
Print[dsptmoi];
]
TimPhanTu[ds]

(* cau f *)

dsnt=Select[ds,PrimeQ]

(* Cau g *)

dschan= Select[ds,EvenQ];
Print["danh sach chan: ",dschan];
dsle=Select[ds,OddQ];
Print["Danh sach le: ",dsle];

Bài 3: Tạo ra một ma trận cấp (n,n+1) với các số nguyên ngẫu nhiên, cột thứ n+1 chính là hệ số tự do của hệ phương trình tuyến tính n phương trình và n biến. Hãy thực hiện các yêu cầu sau:
a) Hãy trích ma trận (n,n+1) đã cho thành ma trận cấp (n,n) bằng cách bỏ ra cột thứ n+1.
b) Đưa ma trận cấp (n,n) đã trích về dạng tam giác trên và tam giác dưới. Tính định thức của ma trận.
c) Tìm ma trận nghịch đảo của ma trận đã trích nếu có.
d) Tìm nghiệm phương trình tuyến tính


n= Input["Nhap vao n "];
matran= Table[Random[Integer,{0,10}],{n},{n+1}];
MatrixForm[matran]

(* cau a *)

matranmoi={};
For[i=1,in,i++,
matranmoi=AppendTo[matranmoi,Take[matran[[i]],n]]]

Print[MatrixForm[matranmoi]];

(* cau b *)

matrantren= Table[If[a>b,0,matranmoi[[a]][[b]]],{a,n},{b,n}];
MatrixForm[matrantren]
matranduoi=Table[If[a<b,0,matranmoi[[a]][[b]]],{a,n},{b,n}];
MatrixForm[matranduoi]
Det[matrantren]
Det[matranduoi]
Det[matranmoi]

(* Cau c: tim ma tran nghich dao *)

matrannghichdao=Inverse[matranmoi];
MatrixForm[matrannghichdao]

(* cau d *)
hstd ={};
For[i=1,in,i++,
hstd=AppendTo[hstd,Last[matran[[i]]]]
]
MatrixForm[hstd]
LinearSolve[matranmoi,hstd]

Bài 4: Tạo danh sách L gồm 100 phần tử với các phần tử thuộc khoảng [5,100]
a) Tính tổng các phần tử trong danh sách.
b) Tính tổng các phần tử > 50 trong danh sách.
c) Tạo danh sách mới gồm những số lẻ trong danh sách L và tính tổng danh sách mới.
d) Tính tổng tất cả các số chẳn trong danh sách.
e) Liệt kê các số nguyên tố trong danh sách và tính tổng các số nguyên tố đó.
f) Tìm những số chia hết chia 5 trong L.


ds=Table[Random[Integer,{5,100}],{100}]

(* Cau a: *)

Sum[ds[[i]],{i,Length[ds]}]
TinhTong[ds]:=Module[{tong,i},
tong=0;
For[i=1,iLength[ds],i++,
tong+=ds[[i]];
]
Print["Tong cac phan tu trong danh sach: ",tong]
]
tong=TinhTong[ds];

(* Cau b: *)

TongLonhon50[ds]:=Module[{tong,i},
tong=0;
For[i=1,iLength[ds],i++,
If[ds[[i]]50,tong+=ds[[i]]];
]
Print["Tong cac phan tu lon hon 50: ",tong]
]
TongLonhon50[ds];

(* Cau c: *)

TongChan[ds]:=Module[{tong,i},
tong =0;
For[i=1,iLength[ds],i++,
If[Mod[ds[[i]],2]0, tong+=ds[[i]]]
]
Print["Tong cac phan tu chan trong danh sach: ",tong]
]
TongChan[ds];

(* Cau d: *)

DsLe[ds]:=Module[{danhsachle,i,tong},
danhsachle={};
tong=0;
For[i=1,iLength[ds],i++,
If[OddQ[ds[[i]]],danhsachle=AppendTo[danhsachle,ds[[i]]]; tong+=ds[[i]]]
]
Print["Danh sach cac so le: ",danhsachle]
Print["Tong danh sach cac phan tu le: ",tong]
]
DsLe[ds];

(* Cau e: *)

DsSoNguyenTo[ds]:=Module[{dsnt,i,tong},
tong=0;
dsnt={};
For[i=1,iLength[ds],i++,
If[PrimeQ[ds[[i]]],dsnt=AppendTo[dsnt,ds[[i]]];tong+=ds[[i]]]
]
Print["Danh sach cac so nguyen to: ", dsnt]
Print["Tong cac phan tu trong ds: ",tong]
]
DsSoNguyenTo[ds];

(* Cau f: *)

SoChiaHetCho5[ds]:=Module[{dschia5,i},
dschia5={};
For[i=1,iLength[ds],i++,
If[Mod[ds[[i]],5]0,dschia5=AppendTo[dschia5,ds[[i]]]]
]
Print["Danh sach cac so chia het cho 5: ",dschia5]
]
SoChiaHetCho5[ds];

Bài 5: Tạo danh danh sách ds số lẻ từ 1 đến 60.
a) Tính tổng các số trong ds
b) Tính tổng bình phương các số trong danh sách 1 ^ 2 + 3^2 + … 59^2
c) Tạo danh sách mới gồm 30 số nguyên ngẫu nhiên trong đoạn[-100,100] và Trộn với danh sách ds thành một danh sách mới theo thứ tự xen kẻ
d) Tính trung bình của các phần tử trong danh sách mới
e) Tạo ra danh sách mới từ ds với các phần tử ở vị trí chẳn.
f) Tính tổng các phần tử ở vị trí chẳn
g) Tạo ra danh sách mời bằng cách loại bỏ đi các số nguyên tố.

ds= Table[i,{i,1,60,2}]
(* Cau a: *)

Sum[ds[[i]],{i,Length[ds]}]

(* Cau b: *)

Sum[ds[[i]]^2,{i, Length[ds]}]

(* Cau c: *)

dsmoi=Table[Random[Integer,{-100,100}],{30}]
dsmoi1={};
For[i=1,iLength[ds],i++,
dsmoi1=AppendTo[dsmoi1,ds[[i]]];
dsmoi1=AppendTo[dsmoi1,dsmoi[[i]]];
]
Print[dsmoi1]

(* Cau d: *)

TinhTrungBinh[dsmoi1]:=Module[{tong,i},
tong=0;
For[i=1,iLength[dsmoi1],i++,
tong+=dsmoi1[[i]];
]
Print["Trung binh cac phan tu trong danh sach: ", N[tong/Length[dsmoi1]]]
]
TinhTrungBinh[dsmoi1];

(* Cau e: *)

dsmoichan=Table[ds[[i]],{i,2,Length[ds],2}]

(* Cau f: *)

Sum[dsmoichan[[i]],{i,Length[dsmoichan]}]

(* Cau g: *)

dsnt=Complement[ds,Select[ds,PrimeQ]]
//EvenQ[Lay so chan]
//OddQ[Lay so Le]

Bài 6: Tạo danh sách gồm 30 số nguyên ngẫu nhiên từ [20,90]
a) Tạo L1(các số chẳn trong danh sách), L2(các số lẻ trong danh sách) từ danh sách L
b) Tạo L3 bằng cách lấy các số nguyên tố trong L.
c) Tạo L4 bằng cách ghép L1 và L3 theo thứ tự tăng dần
d) Tạo L5 bằng cách ghép L1 và L3 theo thứ tự giảm dần
e) Phát sinh ngẫu nhiên danh sách S gồm 30 phần tử lẻ trong khoảng (20,90)


L = Table[Random[Integer,{20,90}],{30}]
(* Cau a: *)

L1 = Select[L,EvenQ]
L2 = Select[L,OddQ]

(* Cau b: *)

L3 = Select[L,PrimeQ]

(* Cau c: *)

L4= Sort[Join[L1,L3]]

(* Cau d: *)

L5= Sort[Join[L1,L3],Greater]

(* Cau e: *)

S={};
While[Length[S]30,
x=Random[Integer,{20,90}];
If[OddQ[x],S= AppendTo[S,x]]
]
Print[S]

Bài 7: G



Bài 8: G

Bài 9: G


Bài 10: G



Bài 11: H

Bài 12: G

Bài 13: H


Show[Graphics[{
Line[{{0,0},{1,1},{0,1},{1,0},{0.5,1.4},{0,0}}]
}],AspectRatioAutomatic]

Graphics
Show[Graphics[{
Circle[{0,0},1],
Line[{{-0.9,-0.5},{0.9,0.5},{-0.9,0.5},{0.9,-0.5},{0,1},{-0.9,-0.5}}]
}],
AspectRatioAutomatic]

Graphics
Show[Graphics[{
Line[{{1,3},{2,2},{2,0},{0,0},{2,2},{0,2},{1,3}}],
Line[{{2,0},{0,2},{0,0}}]
}],
AspectRatioAutomatic]

Graphics
Show[Graphics[{
Line[{{0,2},{2,2},{2,0},{0,0},{0,2}}],
Line[{{2,2},{3,2},{3,0},{2,0}}],
Line[{{0,2},{0.4,3},{2.7,3},{2,2}}],
Line[{{2.7,3},{3,2},{2,1},{3,1},{2,0}}],
Line[{{2,2},{3,1}}],
Line[{{2,1},{3,0}}],
Line[{{0.8,0},{0.8,1.6},{0,0}}],
Line[{{1.2,0},{1.2,1.6},{2,0}}],
Line[{{0.8,0},{0,1.6},{2,1.6},{1.2,0}}],
Line[{{0,2},{2,1.6}}],
Line[{{0,1.6},{2,2}}],
Table[Circle[{x,2.7},0.1,{Pi,2*Pi}],{x,0.35,2.4,0.2} ],
Table[Circle[{x,2.3},0.1,{Pi,2*Pi}],{x,0.21,2.2,0.2} ]

}],
AspectRatioAutomatic]

Graphics

Bài 14: Xây dựng Module tính gần đúng căn bậc N bằng công thứ Newton

CanBacNcuaX[n_,x_]:=Module[{sapxi,tam},
tam=N[x,30];
sapxi=N[x,40];
While[sapxi^n  tam,
sapxi=((n-1)*sapxi+ x/(sapxi^(n-1)))/n;
]
Print["Can bac ",n, " cua ",x ,"= ",N[sapxi,30]]
]
CanBacNcuaX[3,27];

Bài 15: Xây dựng Module tính gần đúng căn bậc 2 bằng công thứ Newton
CanBac2[x_]:=Module[{sapxi,two},
sapxi=N[x,40];
two=N[x,30];
While[sapxi^2 two,
sapxi=(sapxi + x/sapxi)/2;
]
Print["Can bac hai cua: ",x , " = ",N[sapxi,30]]
]
CanBac2[2];

Bài 16: Giải phương trình bậc nhất ax + b = 0

PhuongTrinhBac1[]:=Module[{x},
a=Input["Nhap a"];
b=Input["Nhap b"];
If[a0,If[b0,Print["Phuong trinh vo so nghiem"],Print["Phuong trinh vo nghiem"]],x=-b/a;
Print["Nghiem cua phuong trinh : ",N[x,3]]]
]
PhuongTrinhBac1[]

Bài 17: Giải phương trình bậc hai ax2 + bx + c =0

PhuongTrinhBac2[]:=Module[{x,x1,x2,a,b,c,delta},
a=Input["Nhap a"];
b=Input["Nhap b"];
c=Input["Nhap c"];
If[a0,
If[b0,
If[c0,Print["Phuong trinh vo so nghiem"],Print["Phuong trinh vo nghiem"]],
Print["nghiem cua phuong trinh la x = ",-c/b]
],
delta=b*b-4*a*c;
If[delta<0,Print["Phuong trinh vo nghiem"],
If[delta0,Print["Phuong trinh co nghiem kep: x1 = x2 = ",-b/(2*a )],
Print["Phuong trinh co 2 nghiem phan biet: "];
x1=(-b- Sqrt[delta])/(2*a);
x2=(-b+ Sqrt[delta])/(2*a);
Print["x1 = ",N[x1,5]];
Print["x2 = ",N[x2,5]];
]
]
]
]
PhuongTrinhBac2[]

Bài 18: Xây dưng module tính gần đúng tích phân bằng công thức Simpson. Các tham số nhập từ bàn phím

Simpson[]:=Module[{a,b,h,F,dx,dayy,i,n,tong},
F[x_]=Input["Nhap ham so F[x]"];
a=Input["nhap a"];
b=Input["Nhap b"];
n=Input["Nhap so doan con"];
h=Abs[(b-a)/(2*n)];
dx=Table[a+i*h,{i,0,2*n}];
dayy=Table[F[dx[[i]]],{i,1,2*n+1}];
tong=N[(h/3)*(dayy[[1]]+dayy[[2*n+1]] + 4*(Sum[dayy[[i]],{i,2,2*n,2}])+2*(Sum[dayy[[i]],{i,3,2*n-1,2}]))];
Print[tong]
]
Simpson[]

Bài 19: Xây dưng module tính gần đúng tích phân bằng công thức hình thang. Các tham số nhập từ bàn phím


HinhThang[]:=Module[{a,b,n,h,F,tong,dx,dayy,i,tongtam},
F[x_]=Input["Nhap ham so F[x]"];
a=Input["Nhap a"];
b=Input["Nhap b"];
n=Input["Nhap so doan con"];
h=Abs[(a-b)/n];
dx=Table[a+i*h,{i,0,n}];
dayy=Table[F[dx[[i]]],{i,1,n+1}];
tongtam=Sum[dayy[[i]],{i,2,n}];
tong=N[h*((dayy[[1]]+dayy[[n+1]])/2 + tongtam)];
Print[tong];
]
HinhThang[]

Bài 20: Xây dựng Module tìm nghiệm gần đúng của phương trình bằng phương pháp chia đôi. Các tham số nhập từ bàn phím.

PPChiaDoi[ss_]:=Module[{a,b,c,F,e},
F[x_]=Input["Nhap ham so "];
a=Input["Nhap a"];
b=Input["Nhap b"];
e=Abs[b-a];
While[e>ss,
c=(a+b)/2;
If[F[c]*F[a]<0,b=c,a=c];
e=Abs[b-a];
];
Return[N[a]];
]
Print["Ket qua phuong phap chia doi: ",PPChiaDoi[0.00001]]

Bài 21: Xây dựng Module tìm nghiệm gần đúng của phương trình bằng phương pháp dây cung . Các tham số nhập từ bàn phím.

PPDayCung[ss_]:=Module[{a,b,F,x1,x0,e},
F[x_]=Input["Nhap ham so f(x)"];
a=Input["Nhap a"];
b=Input["Nhap b"];
e=Abs[b-a];
g[x_]=D[F[x],{x,2}];
If[g[a]*F[b]>0,x0=a;t=b,x0=b;t=a]
While[e>ss,
x1=x0-(F[x0]* (x0-t))/(F[x0]-F[t]);
e=Abs[x1-x0];
x0=x1;
];
Return[N[x1]];
]
PPDayCung[0.00001]

Bài 22: Xây dựng Module tìm nghiệm gần đúng của phương trình bằng phương pháp tiếp tuyến. Các tham số nhập từ bàn phím.

PPTiepTuyen[ss_]:=Module[{a,b,e,x0,x1,x2,F},
F[x_]=Input["Nhap ham so f[x]"];
a=Input["Nhap a"];
b=Input["Nhap b"];
e=Abs[b-a];
g[x_]=D[F[x],x];
t[x_]=D[F[x],{x,2}];
If[t[a]*F[b] >0,x0=b,x0=a];
While[e>ss,
x1=x0-(F[x0]/g[x0]);
e=Abs[x1-x0];
x0=x1;
];
Print["Ket qua cua phuong phap tiep tuyen ",N[x1]];
]


Report this post
Top
 Profile E-mail  
Reply with quote  
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 2 posts ] 


Who is online

Users browsing this forum: No registered users and 1 guest


You can post new topics in this forum
You can reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  
cron

Free Forums · php-BB© · Internationalization Project · Report abuse · Terms Of Use/Privacy Policy
© Forums-Free.com 2009