high

np.random.randint()的用法： np.random.randint(low,high=None,size=None,dtype=‘l’) Method: if low=num1,while high=num2,return random integers from low to high if low=num1,while high=None,return random integers from zero to low if low=num1,while size = num,return num integers from zero to low if low=num1,high=num2,size=(n,m),return a n lines m columns array,in which the num from num1 to num2 a = np.random.randint(10,size=(10,1)) #10行一列 print(a) [[5] [7] [8] [2] [1] [2] [4] [0] [7] [1]] 文章来源: https://blog.csdn.net/ggfujfdd/article/details/90312354

https://leetcode.com/contest/biweekly-contest-11/problems/divide-chocolate/ 这道题的题目意思就是，一个巧克力有n格，每个格子有不同的甜度，将巧克力切k次，选择甜度最低的那块，问怎么切能够使得甜度最低的那块巧克力甜度最大。 比赛的时候第一反应这里有一个很明显的递推关系：从切k-1块到切k块，从k-1加上连续的1~n格就能得到下一个状态，于是很快就得到了一个超时的n3 dp: class Solution { public: int n; int maximizeSweetness(vector<int>& sweetness, int K) { n = sweetness.size(); vector<vector<int>> dp(n, vector<int>(K + 5, 0)); for(int i = 0;i < n;i++) { if(i == 0) dp[i][0] = sweetness[i]; else dp[i][0] = sweetness[i] + dp[i - 1][0]; } for(int k = 1;k <= K; k++) { for(int i = 0;i < n; i++) { int sum = 0; for(int j = i + 1;j < n;j++) { sum

目录 堆排序 快速排序 冒泡排序 选择排序 插入排序 迷宫问题 基数排序 归并排序 斐波那契数列 汉诺塔问题 计数排序 希尔排序 二分查找 单链表 找错， 快速排序 import time import random def cal_time(func): def wrapper(*args, **kwargs): start_time = time.time() res = func(*args, **kwargs) end_time = time.time() print("%s Running time: %s"%(func.__name__, (end_time - start_time))) return res return wrapper 堆排序 import random import time def sift(li, low, high): i = low tmp = li[low] j = 2 * i + 1 while j <= high: if j < high and li[j + 1] > li[j]: j += 1 if li[j] > li[i]: li[i], li[j] = li[j], li[i] i = j j = 2 * i + 1 else: break @cal_time def tree_sort(li, low, high): n

在数组a中，设置一个值key为枢轴。在调整的过程中，设立两个指针low和high；之后逐渐减小high,增加low（low<=high）；并保证a[low]<key，a[high]>key;否则进行记录的交换 代码： func QuickSort(a []int){ if len(a) <= 1{ return } key := a[0] //以第一个数为key low := 0 high := len(a)-1 for low < high { for low < high && a[high] > key { //开始从后往前找小与key的 high -- } a[low] = a[high] //找到key,交换，交换 for low < high && a[low] <= key { //找到key,交换一次之后，换方向从前往后遍历 low ++ } a[high] = a[low] } a[low] = key go QuickSort(a[:low]) go QuickSort(a[low+1:]) } 测试： func main(){ a := []int{0,10,19,24,61,5,121,9,11,34,21,22} base_sort.QuickSort(a) fmt.Println(a)//[0 5 9 10 11 19 21 22 24 34 61

代码：from random import randintdef quick_sort(lst,first,last): low=first high=last if first<last: mid_value=lst[first] while low<high: while low<high and lst[high]>=mid_value: high=high-1 lst[low]=lst[high] while low<high and lst[low]<=mid_value: low=low+1 lst[high]=lst[low] lst[low]=mid_value quick_sort(lst,first,low-1) quick_sort(lst,low+1,last) return lstl=[]for i in range(10): l.append(randint(1,100))print(l)print(l,0,len(l-1))运行结果： [89, 86, 5, 76, 12, 13, 20, 57, 20, 18] [5, 12, 13, 18, 20, 20, 57, 76, 86, 89] 来源： https://www.cnblogs.com/sunflowers-lanqijiu/p/11681134.html

最近通道端口通信，但是要求用到高低位传送数据 def low_high(data): high = hex(data >> 8).lstrip('0x') if len(high) < 2: high = '0' + high low = hex(data).lstrip('0x') if len(low) < 2: low = '0' + low else: low = low[-2:] return low.upper() + high.upper() 来源： https://www.cnblogs.com/yubs/p/11677191.html

一个整数键和一个 有序 整数数组，返回键值在数组中的索引 int rank(int key, int[] a) { int low = 0; int high = a.length - 1; while (low <= high) { int mid = low + (high - low) / 2; if (key < a[mid]) { high = mid - 1; } else if (key > a[mid]) { low = mid + 1; } else { return mid; } } return -1; } 来源： https://www.cnblogs.com/csysky/p/11646618.html

顺序查找 　　顺序查找是指将序列从头开始遍历，直到找到指定的元素为止。 　　在一个元素为n的序列中查找不存在的元素，需要比较n次。顺序查找虽然效率低下，但是却适用于任何序列。 　　顺序查找的代码如下： 1 public static int seqSearch(int[] arr, int val) { 2 for (int i = 0; i < arr.length; i++) { 3 if (arr[i] == val) return i; 4 } 5 return -1; 6 } seqSearch 　　例如，在序列（1, 2, 3, 4, 5, 6, 7, 8, 9）中查找元素7：从1开始比较，直到找到了7所在位标并返回。 　　顺序查找一共比较了7次。 二分查找 　　二分查找是指取有序序列中间的元素作为枢轴，枢轴两边被分割为两个子序列，一边比枢轴大，另一边比枢轴小。这样，查找的元素要么为枢轴，要么在其中一个子序列中。每次递归查找时，可以将区间规模大致缩减一半，从而大大加快查找效率。 　　在一个元素为n的序列中查找不存在的元素，需要比较log 2 n次。二分查找只适用于有序序列。 　　二分查找的代码如下： 1 public static int binarySearch(int[] arr, int low, int high, int val) { 2 if (low >

题目1：在作业5的基础上，再创建一个柱体类，包含矩形对象、高和体积等三个成员变量，一个构造方法进行成员变量初始化，和计算体积、换底两个功能方法，在主类中输入长、宽、高，计算柱体体积，输入新的长、宽、高，创建新的矩形对象，并利用换底方法换底，再次计算柱体体积。 /**创建一个矩形类，有长宽，面积周长的成员变量，求面积，求周长的方法，并且写入成员变量的set，get方法 **/ package com; public class Rec { double len,wid,area,zc;//成员变量的命名 //修改器，访问器 public double getLen() { return len; } public void setLen(double len) { this.len = len; } public double getWid() { return wid; } public void setWid(double wid) { this.wid = wid; } double getzc(){ return zc=(len+wid)*2; } double getar(){ return zc=len*wid; } } /** 创建一个四棱柱类，并且创建高，体积的成员变量，一个Rec类型rec变量， * 并且构造一个构造方法中的参数有double类型的高， *

快速排序–学习笔记 快速排序过程： 【示例】： 初始关键字 ［49 38 65 97 76 13 27 49］ 一趟排序之后 ［27 38 13］ 49 ［76 97 65 49］ 二趟排序之后 ［13］ 27 ［38］ 49 ［49 65］76 ［97］ 三趟排序之后 13 27 38 49 49 ［65］76 97 最后的排序结果 13 27 38 49 49 65 76 97 各趟排序之后的状态 */ //通俗的说，快速排序是选取一个基准元素R，将待排序的数组中的元素与它比较，大于等于它的元素放在它之后， //小于等于它的放在它之前，在它的左边都是小于等于它的元素，右边都是大于等于它的元素 //继续在R左，R右两个待排序的区域进行上述的操作，取一个基准元素S一直操作，直到待排序的区域元素全部拍好序为止 //算法是：1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； //2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； //3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换； //4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换； //5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。