精华内容
下载资源
问答
  • 题目 在以下这个20×20网格,四个处于同一对角线上... 这四个数字的乘积是:26×63×78×14=178869626. 在这个20×20网格,处于任何方向上(上,下,左,右或者对角线)四个相邻数字乘积的最大值是多少?

    题目

    在以下这个20×20的网格中,四个处于同一对角线上的相邻数字用粗体标了出来:
    这四个数字的乘积是:26×63×78×14=1788696.
    在这个20×20网格中,处于任何方向上(上,下,左,右或者对角线)的四个相邻数字的乘积的最大值是多少?

    08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
    49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
    81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
    52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
    22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
    24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
    32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
    67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
    24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
    21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
    78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
    16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
    86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
    19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
    04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
    88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
    04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
    20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
    20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
    01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

    解题方法

    一共有4个方向的连线,横(—),竖(|),左对角线(\),右对角线(/)。
    依次计算四个方向的最大值,取最大值。

    程序

    编程的时候需要注意一点,上面的20×20的网格中,为了美观,所有的数字都是两位的,不足两位前面补0。但是这带来一个问题,编程语言中以0开始的直接数表示这个数是八进制表示的。如012=10,但是08是非法的八进制数。因为八进制只有0~7这8个数。所以,在输入数据时要注意这点。顺便一提,以0x开始的数是十六进制数,如0x12=18。

    public static void solve() {
        int[][] num = { { 8, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 8 },
                { 49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00 },
                { 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65 },
                { 52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91 },
                { 22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80 },
                { 24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50 },
                { 32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70 },
                { 67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21 },
                { 24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72 },
                { 21, 36, 23, 9, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95 },
                { 78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 9, 53, 56, 92 },
                { 16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57 },
                { 86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58 },
                { 19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40 },
                { 04, 52, 8, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66 },
                { 88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69 },
                { 04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36 },
                { 20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16 },
                { 20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54 },
                { 01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48 } };
        int max = 0;
        // 横向,从左到右
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 17; j++) {
                int multi = 1;
                for (int k = 0; k < 4; k++) {
                    multi *= num[i][j + k];
                }
                max = multi > max ? multi : max;
            }
        }
        // 竖向,从上到下
        for (int i = 0; i < 17; i++) {
            for (int j = 0; j < 20; j++) {
                int multi = 1;
                for (int k = 0; k < 4; k++) {
                    multi *= num[i + k][j];
                }
                max = multi > max ? multi : max;
            }
        }
        // 右对角线,从左下到右上
        for (int i = 3; i < 20; i++) {
            for (int j = 0; j < 17; j++) {
                int multi = 1;
                for (int k = 0; k < 4; k++) {
                    multi *= num[i - k][j + k];
                }
                max = multi > max ? multi : max;
            }
        }
        // 左对角线,从左上到右下
        for (int i = 0; i < 17; i++) {
            for (int j = 0; j < 17; j++) {
                int multi = 1;
                for (int k = 0; k < 4; k++) {
                    multi *= num[i + k][j + k];
                }
                max = multi > max ? multi : max;
            }
        }
        // 输出最大值
        System.out.println(max);
    }
    展开全文
  • 以下这个2020网格四个处于同一对角线上相邻数字用红色标了出来: 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 ...

    在以下这个20×20的网格中,四个处于同一对角线上的相邻数字用红色标了出来:

    08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
    49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
    81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
    52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
    22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
    24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
    32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
    67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
    24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
    21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
    78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
    16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
    86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
    19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
    04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
    88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
    04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
    20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
    20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
    01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

    这四个数字的乘积是:26 × 63 × 78 × 14 = 1788696.

    在这个20×20网格中,处于任何方向上(上,下,左,右或者对角线)的四个相邻数字的乘积的最大值是多少?

    public class Test {
    	//从左到右计算最大值
    	public static long leftToRight(int arr[][]){
    		int max = 0;
    		int value = 1;
    		for(int i = 0; i < 20; i ++){
    			for(int j = 0 ;j < 17 ; j++){
    				value = arr[i][j] * arr[i][j+1] * arr[i][j+2] * arr[i][j+3];
    				if(value > max) max = value;
    			}
    			
    		}
    		return max;
    	}
    	//从上到下计算最大值
    	public static long upToDown(int arr[][]){
    		int max = 0;
    		int value = 1;
    		for(int i = 0; i < 17; i ++){
    			for(int j = 0 ;j < 20 ; j++){
    				value = arr[i][j] * arr[i+1][j] * arr[i+2][j] * arr[i+3][j];
    				if(value > max) max = value;
    			}
    			
    		}
    		return max;
    		
    	}
    	//从左上到右下计算最大值
    	public static long left_uToRight_d(int arr[][]){
    		int max = 0;
    		int value = 1;
    		for(int i = 0; i < 17; i ++){
    			for(int j = 0;j < 17 ; j++){
    				value = arr[i][j] * arr[i+1][j+1] * arr[i+2][j+2] * arr[i+3][j+3];
    				if(value > max) max = value;
    			}
    			
    		}
    		return max;
    	}
    	//从右上到左下计算最大值
    	public static long right_uToLeft_d(int arr[][]){
    		int max = 0;
    		int value = 1;
    		for(int i = 3; i < 20; i ++){
    			for(int j = 0 ;j < 17 ; j++){
    				value = arr[i][j] * arr[i-1][j+1] * arr[i-2][j+2] * arr[i-3][j+3];
    				if(value > max) max = value;
    			}
    			
    		}
    		return max;
    	}
    	public static void main(String[] args) {
    		/* 构建20*20整数数组 */
    		int arr[][] = {{8,2,22,97,38,15,0,40,0,75,4,5,7,78,52,12,50,77,91,8},  
    					  {49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,4,56,62,0},  
    					  {81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,3,49,13,36,65},  
    					  {52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71,37,2,36,91},  
    					  {22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80},  
    					  {24,47,32,60,99,3,45,2,44,75,33,53,78,36,84,20,35,17,12,50},  
    					  {32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70},  
    				  	  {67,26,20,68,02,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21},  
    					  {24,55,58,5,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72},  
    					  {21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95},  
    				      {78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56,92},  
    					  {16,39,5,42,96,35,31,47,55,58,88,24,0,17,54,24,36,29,85,57},  
    					  {86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51,54,17,58},  
    					  {19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89,55,40},  
    					  {4,52,8,83,97,35,99,16,7,97,57,32,16,26,26,79,33,27,98,66},  
    					  {88,36,68,87,57,62,20,72,3,46,33,67,46,55,12,32,63,93,53,69},  
    					  {4,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36},  
    					  {20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36,16},  
    					  {20,73,35,29,78,31,90,1,74,31,49,71,48,86,81,16,23,57,5,54},  
    					  {1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1,89,19,67,48},  
    	};  
    		System.out.println("max :" + max(leftToRight(arr),upToDown(arr),left_uToRight_d(arr),right_uToLeft_d(arr)));
    	}
    	private static long max(long a, long b,
    			long c, long d) {
    		long max = a;
    		if(b > max) max = b;
    		if(c > max) max = c;
    		if(d > max) max = d;
    		return max;
    	}
    	
    }
    


    展开全文
  • 以下这个2020网格四个处于同一对角线上相邻数字用红色标了出来: 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 0

    这是一个稍微有难度的题目,容易让人漏掉某种情况,我们先来看一下题目:

    在以下这个20×20的网格中,四个处于同一对角线上的相邻数字用红色标了出来:

    08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
    49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
    81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
    52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
    22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
    24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
    32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
    67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
    24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
    21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
    78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
    16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
    86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
    19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
    04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
    88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
    04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
    20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
    20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
    01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

    这四个数字的乘积是:26 × 63 × 78 × 14 = 1788696.

    在这个20×20网格中,处于任何方向上(上,下,左,右或者对角线)的四个相邻数字的乘积的最大值是多少?

    这里最后一行的(上,下,左,右或者对角线)给你提供了思路,上下是一样的,左右也是一样的,但是对角线却又两条"左上--->右下“,”右上--->左下“。这两种情况是不一样的。我们通常都忘记了最后一种情况,导致最后做错,反正我刚开始就是这么做错的。

    好,我们来看一下程序:

    思路很简单,就是把20X20的放在一个二维数组中,然后分为四种情况分别进行运算就好了。

    use strict;
    use warnings;
    
    my $big=0;
    my $i;
    my $j;
    my $sum;
    my @num=(
    ["08","02","22","97","38","15","00","40","00","75","04","05","07","78","52","12","50","77","91","08"],
    ["49","49","99","40","17","81","18","57","60","87","17","40","98","43","69","48","04","56","62","00"],
    ["81","49","31","73","55","79","14","29","93","71","40","67","53","88","30","03","49","13","36","65"],
    ["52","70","95","23","04","60","11","42","69","24","68","56","01","32","56","71","37","02","36","91"],
    ["22","31","16","71","51","67","63","89","41","92","36","54","22","40","40","28","66","33","13","80"],
    ["24","47","32","60","99","03","45","02","44","75","33","53","78","36","84","20","35","17","12","50"],
    ["32","98","81","28","64","23","67","10","26","38","40","67","59","54","70","66","18","38","64","70"],
    ["67","26","20","68","02","62","12","20","95","63","94","39","63","08","40","91","66","49","94","21"],
    ["24","55","58","05","66","73","99","26","97","17","78","78","96","83","14","88","34","89","63","72"],
    ["21","36","23","09","75","00","76","44","20","45","35","14","00","61","33","97","34","31","33","95"],
    ["78","17","53","28","22","75","31","67","15","94","03","80","04","62","16","14","09","53","56","92"],
    ["16","39","05","42","96","35","31","47","55","58","88","24","00","17","54","24","36","29","85","57"],
    ["86","56","00","48","35","71","89","07","05","44","44","37","44","60","21","58","51","54","17","58"],
    ["19","80","81","68","05","94","47","69","28","73","92","13","86","52","17","77","04","89","55","40"],
    ["04","52","08","83","97","35","99","16","07","97","57","32","16","26","26","79","33","27","98","66"],
    ["88","36","68","87","57","62","20","72","03","46","33","67","46","55","12","32","63","93","53","69"],
    ["04","42","16","73","38","25","39","11","24","94","72","18","08","46","29","32","40","62","76","36"],
    ["20","69","36","41","72","30","23","88","34","62","99","69","82","67","59","85","74","04","36","16"],
    ["20","73","35","29","78","31","90","01","74","31","49","71","48","86","81","16","23","57","05","54"],
    ["01","70","54","71","83","51","54","69","16","92","33","48","61","43","52","01","89","19","67","48"],
    );
    #第一种情况,左---->右
    for($i=0;$i<16;$i++)
    {
    	for($j=0;$j<16;$j++)
    	{
    		$sum = $num[$i][$j]*$num[$i][$j+1]*$num[$i][$j+2]*$num[$i][$j+3];
    		if($sum>$big)
    		{
    			$big=$sum;
    		}
    		else
    		{
    			next;
    		}
    	}
    }
    print "$big\n";
    
    
    #第二种情况,上--->下
    $big=0;
    for($i=0;$i<16;$i++)
    {
    	for($j=0;$j<16;$j++)
    	{
    		$sum = $num[$i][$j]*$num[$i+1][$j]*$num[$i+2][$j]*$num[$i+3][$j];
    		if($sum>$big)
    		{
    			$big=$sum;
    		}
    		else
    		{
    			next;
    		}
    	}
    }
    print "$big\n";
    
    #第三种情况,左上--->右下
    $big=0;
    for($i=0;$i<16;$i++)
    {
    	for($j=0;$j<16;$j++)
    	{
    		$sum = $num[$i][$j]*$num[$i+1][$j+1]*$num[$i+2][$j+2]*$num[$i+3][$j+3];
    		if($sum>$big)
    		{
    			$big=$sum;
    		}
    		else
    		{
    			next;
    		}
    	}
    }
    print "$big\n";
    
    #第四种情况,右上--->左下
    $big=0;
    for($i=4;$i<20;$i++)
    {
    	for($j=1;$j<16;$j++)
    	{
    		$sum = $num[$i][$j]*$num[$i-1][$j+1]*$num[$i-2][$j+2]*$num[$i-3][$j+3];
    		if($sum>$big)
    		{
    			$big=$sum;
    		}
    		else
    		{
    			next;
    		}
    	}
    }
    print "$big\n";
    
    


    得到四个结果,我们看看就知道大小了

    结果如下:

    C:\WINDOWS\system32\cmd.exe /c perl "F:\perl\c.pl"
    48477312
    51267216
    32719995
    70600674
    Hit any key to close this window...
    
    
    
    















    展开全文
  • 以下是命令例子,包含错误语句(直接放到一temp.zlc文本文件即可导入发送): [0]adsfasdf[100] [1]2452345\12 35 df\asfd[100] [0][100]12 35 af[400 [1][100]12 35 af[400 [1]adsfasdf[400] [1]\\\df 12 35\...
  • 在熟悉了Verilog HDL语法之后,使用Verilog HDL设计FPGA遇到的最大困难可能就是不知如何用Verilog HDL语句去描述想要实现电路功能。要克服这一困难,除了提高数字...以下是一种状态普通状态机。 // These
  • Python学习(

    2019-08-21 09:59:58
    (2)、在Python,所有数字型变量都有以下的特点: 都是一**序列**,可以理解为**容器** **取值**:[] **遍历**:for in 计算长度,最大值,最小值,比较,删除 **链接**:+ 和 **重复...


    知识回顾
    (1)、Python中变量分为数字型和非数字型
    数字型:int.float,bool,complex
    非数字型:字符串、列表、元组、字典
    (2)、在Python中,所有的非数字型变量都有以下的特点:

    • 都是一个序列,可以理解为容器
    • 取值:[]
    • 遍历:for in
    • 计算长度,最大值,最小值,比较,删除
    • 连接:+ 和 重复:
    • 切片

    一、列表

    1、列表的定义

    列表变量名 = [内容,中间用逗号,同一个列表可以储存不同类型的数据]
    

    2、列表的常见操作

    name_list = ["zhangsan","lisi"]
    
    #取值
    print(name_list[0])
    
    #取索引
    print(name_list.index("lisi"))
    
    #修改
    name_list[0] = "wangwu"
    
    #增加值
    #append函数向末尾增加
    name_list.append("zhangsan")
    #insert函数向指定位置增加
    name_list.insert(0,"wangmazi")
    #extend函数将另一个列表的值完全加入
    tmp_list = ["tangseng","sunwukong"]
    name_list.extend(tmp_list)
    print(name_list)
    
    #删除数据
    #remove方法删除确定的值
    name_list.remove("tangseng")
    #clear方法删除列表中的所有值
    name_list.clear()
    #pop方法在默认的时候删除列表中最后一个元素,有参数的时候删除指定索引的值并且返回该值
    name_list.pop()
    name_list.pop(0)
    #使用del关键字,删除指定的数据
    #del关键字的本质是将数据从内存中删除,一般不建议使用
    del name_list[0]
    
    #列表 统计(函数)
    #len可以统计列表中元素的个数
    l = len(name_list)
    #count方法可以统计某一个数据在列表中出现的次数
    c = name_list.count("lisi")
    
    #列表排序
    num_list = [6,8,4,1,10]
    #升序排序
    num_list.sort()
    name_list.sort()
    #降序
    num_list.sort(reverse=True)
    #逆序反转
    num_list.reverse()
    
    #循环遍历列表
    for name in name_list:
        print(name,end=" ")
        
    

    列表的循环遍历
    语法:

    for 循环内部使用的变量 in 列表
    

    for in是在Python中为了提高列表的遍历效率,专门提供的迭代iterator遍历。
    与C、Java等语言相同,在使用遍历器遍历的过程中不能进行删除,否则会导致结果不正确,例如下面所示:

    #方法一
    num_list = [1,90,80,8,9,2]
    #删除10以内的数
    for num in num_list:
        if num>=0 and num<=10:
            num_list.remove(num)
    
    print(num_list)
    
    #方法二
    tmp_list = [1,90,80,8,9,2]
    result = []    #注意Python中变量申明的同时必须赋值,才会创建该变量
    for num in tmp_list:
        if num>=0 and num<=10:
            result.append(num)
    print(result)
    
    for num in result:
        tmp_list.remove(num)
    print(tmp_list)
    

    结果
    在这里插入图片描述
    结果分析
    使用方法一,在遍历的过程中删除,应该是导致了迭代器的混乱,所以不能直接删除。
    正确的打开方式应该是将需要删除的数据先存到一个列表中,然后再进行删除!

    列表操作方法总结:
    在这里插入图片描述

    3、区分关键字、函数、方法

    (1)、关键字:是Python内置的,具有特殊意义的标识符,查看Python的关键字的方法为:

    import keyword
    print(keyword.kwlist)
    #关键字使用的后面不需要使用括号
    

    (2)、函数封装了独立的功能,可以直接调用。

    函数名(参数)
    

    (3)、方法
    方法和函数类似,同样是封装了独立的功能。
    方法需要通过对象来调用,表示针对这个对象要做的操作。

    对象.方法名(参数)
    

    二、元组

    1.元组的定义

    定义
    (1)、用于储存一串信息,数据之间用逗号隔开
    (2)、元组用()定义
    (3)、元组的索引从0开始
    (4)、元素不能修改

    创建空的元组
    name = ()

    元组中只包含一个元素的时候,需要在后面加上逗号
    name = (5,)

    2、元组的基本操作

    info_tuple = ("zhangsan",18,1.75)
    
    #取值和取索引
    print(info_tuple[0])
    print(info_tuple.index("zhangsan"))
    
    #count统计一个数据再元组中出现的次数
    print(info_tuple.count("zhangsan"))
    #len函数统计元组中数据的个数
    print(len(info_tuple))
    
    #循环遍历
    for my_info in info_tuple:
        print(my_info)
    

    注意:虽然元素可以for in遍历,但是因为元组可以有很多类型的数据,所以在格式化输出的时候比较复杂,因此很少使用。

    3、元组的使用场景

    (1)、函数的参数和返回值
    (2)、格式字符串,在print函数的格式化输出的时候括号的参数就是一个元组

    print("%s 的年龄是 %d 身高是 %.2f" % ("肖战",28,1.83))
    tmp_str = "%s 的年龄是 %d 身高是 %.2f" % ("肖战",28,1.83)
    print(tmp_str)
    

    (3)、让列表不可以被修改,以保护数据安全

    4、列表和元组之间的转换

    why:
    如果希望列表被保护,不被修改

    操作

    #列表变为元组
    tuple(列表)
    
    #元组变为列表
    list(元组)
    

    三、字典

    1、定义

    (1)、字典是除列表之外Python之中最灵活的数据类型
    (2)、字典可以用来存储多个数据,通常用于存储描述一个物体的相关信息
    (3)、和列表的区别:列表是有序的,字典是无序的,也就是说使用Print进行输出的时候可能与定义的顺序是不同的,但是好像Python3.7以上顺序是固定的
    (4)、字典使用{}进行定义
    (5)、字典是键值对:
    key是索引
    value是值
    键和值之间用冒号隔开,不同的对之间都好
    键不能重复
    值可以是任意的数据类型,但键只能使用字符串数字或者元组

    2、基本用法

    xiaoming = {"name":"xiaoming"}
    
    #取值,取值的时候如果key不存在那么就会报错
    print(xiaoming["name"])
    
    #增加修改值
    #key存在就是修改
    #key不存在就是增加
    xiaoming["age"] = 18
    xiaoming["name"] = "xm"
    
    #删除,删除指定的key
    #如果key不存在,那么会报错
    xiaoming.pop("name")
    
    #统计键值对的数量
    print(len(xiaoming))
    
    #合并键值对
    #如果被合并的字典中有相同的键值对,那么会覆盖原来的键值对,update么
    tmp = {"name":"xiaoming"}
    xiaoming.update(tmp)
    
    #清除
    xiaoming.clear()
    print(xiaoming)
    
    #循环遍历
    for k in xiaoming:
        print(xiaoming[k])
    
    

    3、应用的场景

    (1)、使用字典存储一个物体的全部信息
    (2)、将多个字典组合成一个列表使用
    例如

    info_list = [{"name":"xiaoming",
    "num":1,
    "age":18},
    {"name":"lisi",
    "num":2,
    "age":19},
    ]
    for person in info_list:
        print(person)
    

    四、字符串

    1、定义

    可以使用单引号和双引号,但是如果字符串内容有单引号,那么用双引号定义;如果字符串内容有双引号,那么用单引号定义。

    2、字符串基本操作

    1、类型判断

    在这里插入图片描述

    2、查找替换

    在这里插入图片描述

    3、大小写转换

    在这里插入图片描述

    4、文本对齐

    在这里插入图片描述

    5、去除空白字符

    6、拆分和连接

    在这里插入图片描述常见方法

    hello_str = "hello python"
    
    #统计字符长度
    len(hello_str)
    
    #统计某个字符串出现的次数
    hello_str.count("llo")
    
    #子串出现的位置
    #如果该子串没有出现,那么就会报错
    hello_str.index("llo")
    
    #判断字符只由空格和空白字符(\n,\t,\r)
    tmp = "  \n\t\r"
    tmp.isspace() #输出True
    
    #判断字符串中是否值包含数字,但是都不能判断小数
    num_str = "1"
    
    print(num_str.isdecimal())
    print(num_str.isdigit())
    print(num_str.isnumeric())
    
    #判断字符串是否以指定字符串开头
    hello_str.startswith("hello")
    
    #判断字符串的结束
    hello_str.endswith("python")
    
    #查找指定字符串,返回索引
    #两者之间的区别是,index如果指定字符串不存在那么报错,find返回-1
    hello_str.find("llo")
    hello_str.index("llo")
    
    #替换字符串
    #replace(被替换,替换)
    #replace执行之后会返回一个新的字符串,但是不会修改原字符串的内容
    hello_str.replace("python","world")
    
    
    

    空白字符
    \n,\t,\r(回车)

    3、字符串切片

    切片方法适用于字符串列表元组,这三个都是有序的,都可以通过下标取值。

    切片的方法
    字符串[开始索引:结束索引:步长]
    需要注意的一点是,Python中字符串下标为-1代表的是最后的一个字符,-2代表的是倒数第二个字符
    步长是从当前字符开始计算的,也就是本身这个字符也是在计算范围内的

    注意
    (1)、索引的范围是左闭右开
    (2)、从头开始,开始索引数字可以省略,冒号不能省略
    (3)、到末尾结束,结束索引数字可以省略,冒号不能省略
    (4)、步长默认为1,如果连续切片,数字和冒号都可以省略

    例子

    num_str = "0123456789"
     
     #输出所有的偶数
    print(num_str[::2])
    
    
     #输出所有的奇数
    print(num_str[1::2])
    
     #使用切片的方法将字符串倒序
     #注意这里的就表示倒序,然后-1表示向左切片
    print(num_str[-1::-1])
    print(num_str[::-1])  #is ok
    

    五、公共方法

    1、Python内置函数

    内置函数就是不需要导入工具包可以直接使用的,Python的内置函数有:
    在这里插入图片描述del有两种使用方式:
    (1)、通过关键字的方式 del data
    (2)、函数的方式del(data)

    2、切片

    在这里插入图片描述字典是不能进行切片操作的,因为字典是无序的,是通过键值对进行数据保存的。

    3、运算符

    在这里插入图片描述小知识
    在这里插入图片描述append函数会将添加的东西视为一个。
    当我们需要查看可以使用的方法的时候,可以使用tab键,在终端中查看。

    4、for break

    what:
    在for in遍历的时候,如果是通过break跳出循环的,那么就不执行else中的语句,否则就执行。
    使用的场景
    如果希望在搜索列表是,所有的内容检查之后,都没有发现需要搜索的目标,还希望统一得到一个提示的时候使用。
    例子

    student = [
        {"id":1,
        "name":"xiaoming"},
        {"id":2,
        "name":"lisi"},
        {"id":3,
        "name":"zhangsan"}
    ]
    finid = 4
    for person in student:
        if person["id"] == 4:
            print("find!")
            break
    else:
        print("no find")
    

    六、小技巧

    1、字符串判断

    场景:根据用户输入的数字选择不同的操作。
    技巧
    (1)、使用input那么就是字符串,我们并不需要使用int转换用户输入,可以避免一旦用户输入的不是数字,导致程序运行错误
    (2)、使用in针对列表判断,而不是使用or
    例如
    在这里插入图片描述

    2、pass

    pass就是一个空语句,不做任何事情,一般用做占位符,是为了保持程序结构的完整性。

    3、TODO注释

    在#使用TODO,用于标记需要去做的工作

    4、改变变量名

    在VSCODE中如果要改变变量名,鼠标指向变量-》右键-》重命名,可以一次性改变全部。

    5、Linux上Shebang符号(#!)

    #!这个符号叫做Shebang,通常在Linux系统脚本中的第一行开头使用,指明执行这个脚本文件的解释程序。也就是说可以直接用./*.py执行程序而不是python *.py。

    操作
    (1)、使用which查询python3解释器所在路径
    (2)、修改要运行的主Python文件,在第一行增加

    #! python3解释器的路径

    (3)、修改主Python文件的文件权限,增加执行权限

    sudo chmod +x main.py

    (4)、执行程序

    ./main.py
    不再需要python main.py

    开学前辛苦营业的一天
    在这里插入图片描述

    展开全文
  • 当这接脚电压从1/3 VCC电压以下移至2/3 VCC以上时启动这动作。 Pin 7 (放电) -这接脚和主要输出接脚有相同电流输出能力,当输出为ON时为LOW,对地为低阻抗,当输出为OFF时为HIGH,对地为高阻抗。 ...
  • 小数分隔符用来将一个数字的整数部分与小数部分分隔开。其格式是 <decimal_character><group_separator>。 值范围: 任何单字节字符, '+', '-', ', '>' 除外。 默认值: 从 NLS_TERRITORY 获得 nls_sort: 说明: ...
  •  创建曲面方法很多,可以用点阵直接生成曲面(Fit free form),可以用曲线通过蒙皮、扫掠、四个边界线等方法生成曲面,也可以结合点阵和曲线信息来创建曲面。还可以通过其它例如园角、过桥面等生成曲面。  ...
  • 适合20路以下数字量控制工业场合对小型PLC 需求,直接用三菱梯形图软件GX编程,有断电保持和在线监视功能,具有防雷击、抗强电磁干扰、稳定可靠、性价比高、使用简便特点,可代替国外品牌PLC 用于20点以内...
  • 神奇“6174“!!!

    2013-08-07 16:41:03
    所谓"6174"工程,就是一个四位数,对数字的要求是它的个十百千位上的数字不能完全一样,经过以下n次算数变换总能得到“6174”这样一个结果。... ⑵将⑴四个数字先组合成一个最大的四位数; ⑶...
  •  他把1,2,3,...16 这16个数字填写在4 x 4方格。    如图p1.jpg所示,即:    16 ? ? 13  ? ? 11 ?  9 ? ? *  ? 15 ? 1    表有些数字已经显露出来,还有些用?和*代替。    请你计算出? 和 * 所...
  • 字符串算法问题

    2010-03-01 15:31:00
    已知一组数字:21,25,11,32,12,35,55,77,66 要求按以下规则进行排序:第一个数最大,第二个数最小,* 第三个数是剩下最大的,第四个数是剩下的最小的,依此类推,请设计一个字符界面的程序解决之 C# codes ...
  • 资料里说的是为了防止已失效的连接请求报文段突然又传送到了服务端,因而产生错误。失效的连接是怎样一种情况呢?我们都经历过网络不好的时候,网络的延迟现象也是时有发生的。当客户端发送的一...
  • ELEMENT" 是元素的声明,说明你要定义的是元素; 声明后面的"DESCRIPTION",是元素的名称; "(#PCDATA, DEFINITION)*>"则是该元素的使用规则。规则定义了元素可以包含的内容以及相互的关系。下面的表格概要列...
  • 面试算法题6

    千次阅读 2007-04-21 09:21:00
    /** * 已知一组数字:21,25,11,32,12,35,55,77,66 要求按以下规则进行排序:第一个数最大,第二个数最小, * 第三个数是剩下最大的,第四个数是剩下的最小的,依此类推,请设计一个字符界面的程序解决之....
  • DBX260中文说明书

    2013-04-24 11:07:35
    每一图指示的是每一FX 钮的功能,及其在每操作菜单指导用户的能力。 上一页(PREVIOUS 260GE)-翻至当前所选效果菜单的上一页。 下一页(NEXT 260GE)-翻至当前所有选效果菜单的下一页。 EQ-选择EQ效果菜单...
  • 欧拉计划 11

    2016-12-19 22:39:41
    以下这个20×20网格,四个处于同一对角线上...这四个数字的乘积是:26 × 63 × 78 × 14 = 1788696. 在这个20×20网格,处于任何方向上(上,下,左,右或者对角线)四个相邻数字乘积的最大值是多少?
  • excel使用

    2012-11-25 17:06:01
    由于自定义格式最多只有3个数字段,Excel规定最多只能在前两个数字包括2个条件测试,满足某个测试条件数字使用相应段指定格式,其余数字使用第3段格式。如果仅包含一个条件测试,则要根据不同情况来...
  • Math对象方法Math.ceil(x) 返回大于等于x最小整数;Math.floor(x) 返回小于等于x的最大整数;Math.round(x) 将一小数...经常遇到情况是需要取若干位有效数字的小数于是给Math对象写了以下方法Math.hold(x,n)
  • JavascriptMath对象使用心得

    千次阅读 2006-08-08 12:46:00
    Math对象方法Math.ceil(x) 返回大于等于x最小整数;Math.floor(x) 返回小于等于x的最大整数;Math.round(x) 将一小数...经常遇到情况是需要取若干位有效数字的小数于是给Math对象写了以下方法Math.hold(x,n) 
  • 幸运的是,Eclipse 附带了一标准的插件集,包括Java开发工具(Java Development Kit,JDK)。Eclipse是著名的跨平台的自由集成开发环境(IDE)。最初主要用来Java语言开发,通过安装不同的插件Eclipse可以支持不同...
  • Proteus仿真—40单片机初学程序.

    热门讨论 2009-04-13 13:00:56
    如图4.3.1所示,AT89S51单片机P1.0-P1.3接四个发光二极管L1-L4,P1.4-P1.7接了四个开关K1-K4,编程将开关状态反映到发光二极管上。(开关闭合,对应灯亮,开关断开,对应灯灭)。 2. 电路原理图 图...
  • 运用网上报名数据库的一个最大的优点是能将所有报名资料都汇总在一起,使会展组织者拥有一不断更新而准确的报告。 住宿安排:展会组织者还应该引导展会参加者在网上预定旅店,可以把免费团体住宿安排应用软件、...
  • 这里需要特别说明的是,如果你选择了驱动U盘的选项,在启动过程会在扫描USB设备时停顿比较久(1-2分钟不等),大家不要以为死机,请耐心等待一下。 4、DOS成功后,会显示DOS LOADING SUCCESSFUL的字样并处于A:\>...
  • 阶段发展迅速,互联网应用趋于多样化,其中变化最大的是由web 1.0网站创造内容的时代变为由用户创造内容的web 2.0时代。 在web 2.0应用,博客(Blog)是web 2.0核心应用最典型、最流行的代表之一,也是web ...
  • 洛谷#P1457#城堡

    2019-05-06 20:40:51
    城堡 ...每个数字是由以下四个整数某个或某几个或一个都没有加起来。 1: 在西面有墙 2: 在北面有墙 4: 在东面有墙 8: 在南面有墙 解法 二进制处理一下之后连边,直接用mp[i][j][k]表示(i,j)...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 149
精华内容 59
关键字:

以下四个数字中最大的是