+ Trả lời chủ đề
Hiện kết quả từ 1 tới 2 của 2

Chủ đề: Bài tập tổng hợp - Code bài tập 1

  1. #1
    Status : ThanhTuan_Alpha đang ẩn
    Tham gia ngày : Aug 2011
    Bài gửi : 203

    Bài tập tổng hợp - Code bài tập 1

    Bài 1: 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.
    Sử dụng hàm Random kết hợp với Table
    Mã:
    n = Input["Nhap gia tri cua n"];
    L = Table[Random[Integer, {20, 120}], {n}]
    a. In ra phần tử đầu, giữa và cuối DS.
    Mã:
    (*Cau a*)
    Print["Phan tu dau danh sach:", L[[1]]];
    Print["Phan tu CUOI danh sach:", L[[n]]];
    b. Sắp xếp DS theo chiều tăng giảm theo hai cách.
    - Dùng hàm Sort
    Mã:
    (*Cau b*)
    Print["Su dung ham Sort: ", Sort[L, Greater]];
    - Sử dụng thuật toán Bubble Sort
    Mã:
    (*Module sắp xếp theo thuật toán Bubble Sort*)
    BubbleSort[L_] := Module[{L1, i, j, temp, n},
          	n = Length[L];
          	L1 = L;
          	For[i = 1, i < n, i++,
            		For[j = i + 1, j ≤ n, j++,
                		If[L1[[i]] > L1[[j]],
                    		temp = L1[[i]];
                    		L1[[i]] = L1[[j]];
                    		L1[[j]] = temp;	
                    	    ];
                	];
            	];
          	Return[L1];
          ];
    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 theo hai cách.
    - Sử dụng hàm Sum
    Mã:
    Print["Tong ds dung ham Sum:", Sum[L[[i]], {i, n}]];
    - Cài đặt Module tính tổng
    Mã:
    (*Cau d*)
    Tong[L_] := Module[{temp, n, i},
          n = Length[L];
          temp = 0;
          For[i = 1, i ≤ n, i++,
            	temp += L[[i]];
            ];
          	Return[temp];
          ];

    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.
    Phương pháp

    - Drop
    Mã:
    (*Cau e*)
    (*Dung ham Drop*)
    Tach[L_] := Module[{L1, i, n},
          	i = 1;
          	n = Length[L];
          	L1 = L;
          	While[i ≤ n,
            		If[L1[[i]] > 70 || L1[[i]] < 50,
                			L1 = Drop[L1, {i}];
                			n--;
                			,
                			i++;
                		];
            	];
          	Return[L1];
          ];
    - Thuật toán (Append)
    Mã:
    (*Dung ham Append*)
    Tach1[L_] := Module[{L1, i, n},
          	L1 = {};
          	n = Length[L];
          	For[i = 1, i ≤ n, i++,
            		If[L[[i]] <= 70 && L[[i]] >= 50, 
                			L1 = Append[L1, L[[i]]];
                		];
            
            	];
          	Return[L1];
          ];
    - Select
    Mã:
    Select[L, # > 50 && # < 70 &]
    f. Tìm trong DS tất cả các số nguyên tố.
    - Sử dụng hàm PrimeQ
    Mã:
    (*Cau f*)
    NguyenTo[L_] := Module[{L1, n, i},
          n = Length[L];
          L1 = {};
          For[i = 1, i ≤ n, i++,
            If[PrimeQ[L[[i]]], L1 = Append[L1, L[[i]]]];
            ];
          Return[L1];
          ];
    - Sử dụng hàm Select và PrimeQ
    Mã:
    Select[L, PrimeQ[#] &]
    g. Chia DS thành hai DS mới theo DS số chẵn và DS số lẻ.
    Ví dụ: Ds = {2,7,8,3,11,6,7}->{2,8,6},{7,3,11,7}

    - Sử dụng hàm EvenQ và OddQ
    Mã:
    (*Cau g*)
    TachDS[L_] := Module[{L1, L2, i, n},
          	n = Length[L];
          	L1 = {};
          	L2 = {};
          	For[i = 1, i ≤ n, i++,
            		If[EvenQ[L[[i]]],
                		L1 = Append[L1, L[[i]]];
                		,
                		L2 = Append[L2, L[[i]]];
                	];
            	];
          	Return[{L1, L2}];
          ];
    - Sử dụng hàm Select
    Mã:
    (*Cau g*)
    Print["Su dung ham Select"];
    L1 = Select[L, EvenQ]
    L2 = Select[L, OddQ]

  2. #2
    Status : ThanhTuan_Alpha đang ẩn
    Tham gia ngày : Aug 2011
    Bài gửi : 203

    Code mẫu

    Mã:
    BubbleSort[L_] := Module[{L1, i, j, temp, n},
          	n = Length[L];
          	L1 = L;
          	For[i = 1, i < n, i++,
            		For[j = i + 1, j ≤ n, j++,
                		If[L1[[i]] > L1[[j]],
                    		temp = L1[[i]];
                    		L1[[i]] = L1[[j]];
                    		L1[[j]] = temp;	
                    	    ];
                	];
            	];
          	Return[L1];
          ];
    
    (*Cau e*)
    (*Dung ham Drop*)
    Tach[L_] := Module[{L1, i, n},
          	i = 1;
          	n = Length[L];
          	L1 = L;
          	While[i ≤ n,
            		If[L1[[i]] > 70 || L1[[i]] < 50,
                			L1 = Drop[L1, {i}];
                			n--;
                			,
                			i++;
                		];
            	];
          	Return[L1];
          ];
    
    (*Dung ham Append*)
    Tach1[L_] := Module[{L1, i, n},
          	L1 = {};
          	n = Length[L];
          	For[i = 1, i ≤ n, i++,
            		If[L[[i]] <= 70 && L[[i]] >= 50, 
                			L1 = Append[L1, L[[i]]];
                		];
            
            	];
          	Return[L1];
          ];
    
    (*Cau g*)
    TachDS[L_] := Module[{L1, L2, i, n},
          	n = Length[L];
          	L1 = {};
          	L2 = {};
          	For[i = 1, i ≤ n, i++,
            		If[EvenQ[L[[i]]],
                		L1 = Append[L1, L[[i]]];
                		,
                		L2 = Append[L2, L[[i]]];
                	];
            	];
          	Return[{L1, L2}];
          ];
    
    (*Cau d*)
    Tong[L_] := Module[{temp, n, i},
          n = Length[L];
          temp = 0;
          For[i = 1, i ≤ n, i++,
            	temp += L[[i]];
            ];
          	Return[temp];
          ];
    (*Cau f*)
    
    NguyenTo[L_] := Module[{L1, n, i},
          n = Length[L];
          L1 = {};
          For[i = 1, i ≤ n, i++,
            If[PrimeQ[L[[i]]], L1 = Append[L1, L[[i]]]];
            ];
          Return[L1];
          ];
    
    (*BAI TAP TONG HOP 1*)
    (*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.Sử dụng hàm Random kết hợp với Table *)
    
    n = Input["Nhap gia tri cua n"];
    L = Table[Random[Integer, {20, 120}], {n}];
    Print["Danh sach ban dau"];
    Print[L];
    
    (*Cau a : in ra phần tử đầu, giữa và cuối DS*)
    Print["---------- Cau a ----------"];
    Print["Phan tu DAU danh sach: ", L[[1]]];
    Print["Phan tu CUOI danh sach: ", L[[n]]];
    
    (*Cau b : sắp xếp DS theo chiều tăng giảm theo hai cách*)
    Print["---------- Cau b ----------"];
    Print["Su dung ham Sort: ", Sort[L, Greater]];
    Print["Su dung thuat toan Bubble Sort:", BubbleSort[L]];
    (*Cau d : tính tổng các phần tử trong DS theo hai cách*)
    
    Print["---------- Cau d ----------"];
    Print["Tong ds dung ham Sum: ", Sum[L[[i]], {i, n}]];
    Print["Tong ds dung ham Tong: ", Tong[L]];
    
    (*Cau 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*)
    Print["---------- Cau e ----------"];
    Print["Dung ham Drop: ", Tach[L]];
    Print["Dung ham Append: ", Tach1[L]];
    Print["Su dung Select: ", Select[L, # > 50 && # < 70 &]]
    (*Cau f : tìm trong DS tất cả các số nguyên tố*)
    
    Print["---------- Cau f ----------"];
    Print["Cac so nguyen to trong danh sach:"];
    Print[NguyenTo[L]];
    Print["Su dung ham Select"];
    Print[Select[L, PrimeQ]];
    
    (*Cau g : chia DS thành hai DS mới theo DS số chẵn và DS số lẻ*)
    Print["---------- Cau g ----------"];
    Print["Su dung ham Select"];
    Print["Danh sach so le:"];
    Print[Select[L, EvenQ]];
    Print["Danh sach so chan:"];
    Print[Select[L, OddQ]];
    Print["Su dung Module cai dat"];
    Print[TachDS[L]];

+ Trả lời chủ đề

Quyền viết bài

  • Bạn không thể gửi chủ đề mới
  • Bạn không thể gửi trả lời
  • Bạn không thể gửi file đính kèm
  • Bạn không thể sửa bài viết của mình
Trang Chủ Việc Làm Gia Sư Gia sư