算法基础——1.6练习

[java]  view plain copy

1. 例一:  

[java]  view plain copy

1. /*数字数码管 
2. 数字或字母可以用7位数码管显示（就是排列为8字形的7个数码管） 
3.  
4.       @@@@          0 
5.      @    @       1   2 
6.      @    @         3 
7.       @@@@        4   5 
8.      @    @         6 
9.      @    @ 
10.       @@@@ 
11.  
12. 对于大型灯管，为了节约使用，在切换数字的时候，如果该灯管的状态没有改变，则不需要对该灯管关了再开。 
13. 已知一个数字变化的系列，求7个数码管开关的动作。 
14. 3：0,2,3,5,6 
15. 6：0,1,4,6,5,3 
16. */  
17. /* 
18.  数字  所用到的数码管 
19. 0 014652 
20. 1 14或者25 
21. 2 02346 
22. 3：0,2,3,5,6 
23. 4 1325 
24. 5 01356 
25. 6：0,1,4,6,5,3 
26. 7 025 
27. 8 0123456 
28. 9 012356 
29. */  
30. public class Homework6 {      
31.     public static void main(String[] args) {  
32.         int d[] = {0,0,0,0,0,0,0};//用来记录7个数码管的开关状态，0表示关，1表示开  
33.         int arr[][] = {{1,1,1,0,1,1,1},//用来记录0到9这些数字用数码管表示时，数码管的开关状态，一行为一个数字  
34.                        {0,1,0,0,1,0,0},  
35.                        {1,0,1,1,1,0,1},  
36.                        {1,0,1,1,0,1,1},  
37.                        {0,1,1,1,0,1,0},  
38.                        {1,1,0,1,0,1,1},  
39.                        {1,1,0,1,1,1,1},  
40.                        {1,0,1,0,0,1,0},  
41.                        {1,1,1,1,1,1,1},  
42.                        {1,1,1,1,0,1,1}};  
43.           
44.         String numbers;//用来存储数字变化的系列  
45.         System.out.print("请输入要变化的数字序列:\t");  
46.         Scanner scan = new Scanner(System.in);  
47.         numbers = scan.next();  
48.           
49.         /*      在切换数字的时候，如果该灯管的状态没有改变，则不需要对该灯管关了再开。 
50.          * 原来数码管为开1 现在为1 状态不变 
51.          *          1      0 变为现在状态0 
52.          *          0      1 变为现在状态1 
53.          *          0      0 状态不变 
54.          *          也就是状态相等，不变；状态不等，变为现在状态*/  
55.         for(int i = 1; i < numbers.length(); ++i)  
56.         {  
57.             int pre = Integer.parseInt(String.valueOf(numbers.charAt(i-1)));//取出字符串中变化前的数  
58.             int curr = Integer.parseInt(String.valueOf(numbers.charAt(i)));//取出字符串中要变化成的数  
59.             System.out.println("从" + pre + "转化到" + curr + "灯管的开关状态变化");  
60.             for(int k = 0; k < 7; ++k)//遍历灯管状态  
61.             {  
62.                 if (arr[pre][k] == arr[curr][k])//变化前的数 与 变化成的数 的第k个灯管 的状态相同  
63.                     System.out.print(k + "号灯管状态不变\t");  
64.                 else {  
65.                     d[k] = arr[curr][k];//变化前的数 与 变化成的数 的第k个灯管 的状态不同，并变为现在状态  
66.                     System.out.print(k + "号灯管状态变为:" + d[k] + "\t");  
67.                 }  
68.             }  
69.             System.out.println();  
70.         }  
71.     }  
72. }  

例二：

[java]  view plain copy

1. /*隐藏密码 
2. 密码备忘扰乱法 
3. 我们的密码如果很长很复杂，容易忘记。如果太简单，不安全。 把密码记录在本子上，更容易泄密！ 
4. 有人想了这么个办法，把密码嵌入一堆随机的数字中。 
5. 因为每个人对密码完全记住困难，但从一些线索中回忆出来就很容易。 
6. 密码：75383 
7. 3 5 6 4 7 2 8 6 
8. 5 4 7 2 7 0 7 4 
9. 1 6 5 9 5 8 0 3 
10. 1 6 7 0 3 6 8 9 
11. 3 6 4 7 8 0 9 4 
12. 3 4 6 9 3 6 8 9 
13. 2 1 3 6 7 8 1 3 
14. 2 7 3 9 4 6 3 5 
15. 嵌入时，可以横向或纵向。如果再复杂点，可以设计对角线。*/  
16.   
17. public class Homework7 {  
18.   
19.     public static void main(String[] args) {  
20.         int row = 8, clum = 8;//二维数组行数和列数  
21.         int array[][] = new int [row][clum];//二维数组存储随机数和密码  
22.         int code[] = {7,5,3,8,3};  
23.           
24.         //为二维数组产生随机数  
25.         for(int i = 0; i < row; ++i)  
26.             for(int j = 0; j < clum; ++j)  
27.                 array[i][j] = (int) (Math.random()*10);  
28.           
29.         //嵌入密码  
30.         //insertCode2(code, array, row, clum);//嵌入到纵向  
31.         insertCode1(code, array, row, clum);//嵌入到对角线上  
32.           
33.         //输出二维数组  
34.         for(int i = 0; i < row; ++i){  
35.             for(int j = 0; j < clum; ++j){  
36.                 System.out.print(array[i][j] + " ");  
37.             }  
38.             System.out.println();  
39.         }  
40.     }  
41.       
42.     //嵌入到对角线上  
43.     private static void insertCode1(int code[], int array[][], int row, int clum)  
44.     {  
45.         for(int i = 0, j  = 1; i < code.length && j < row; ++i, ++j )  
46.             array[j][j] = code[i];  
47.     }  
48.       
49.     //嵌入到纵向  
50.     private static void insertCode2(int code[], int array[][], int row, int clum)  
51.     {  
52.         for(int i = 0, j  = 1; i < code.length && j < row; ++i, ++j )  
53.             array[j][4] = code[i];//第四列  
54.     }  
55.       
56.     //嵌入到横向  
57.     private static void insertCode3(int code[], int array[][], int row, int clum)  
58.     {  
59.         for(int i = 0, j  = 1; i < code.length && j < row; ++i, ++j )  
60.             array[4][j] = code[i];//第四行  
61.     }  
62.   
63. }