发表更新学习7 分钟读完 (大约1012个字)

第一课第四周作业

General methodology

As usual you will follow the Deep Learning methodology to build the model:

1. Initialize parameters / Define hyperparameters
2. Loop for num_iterations:
    a. Forward propagation
    b. Compute cost function
    c. Backward propagation
    d. Update parameters (using parameters, and grads from backprop) 
4. Use trained parameters to predict labels
阅读更多
发表更新学习15 分钟读完 (大约2256个字)

第一课第四周作业

作业提纲

  • Initialize the parameters for a two-layer network and for an $L$-layer neural network.
  • Implement the forward propagation module (shown in purple in the figure below).
    • Complete the LINEAR part of a layer’s forward propagation step (resulting in $Z^{[l]}$).
    • We give you the ACTIVATION function (relu/sigmoid).
    • Combine the previous two steps into a new [LINEAR->ACTIVATION] forward function.
    • Stack the [LINEAR->RELU] forward function L-1 time (for layers 1 through L-1) and add a [LINEAR->SIGMOID] at the end (for the final layer $L$). This gives you a new L_model_forward function.
  • Compute the loss.
  • Implement the backward propagation module (denoted in red in the figure below).
    • Complete the LINEAR part of a layer’s backward propagation step.
    • We give you the gradient of the ACTIVATE function (relu_backward/sigmoid_backward)
    • Combine the previous two steps into a new [LINEAR->ACTIVATION] backward function.
    • Stack [LINEAR->RELU] backward L-1 times and add [LINEAR->SIGMOID] backward in a new L_model_backward function
  • Finally update the parameters.

Figure1

阅读更多
发表更新学习1 分钟读完 (大约208个字)

python查漏补缺之基本的数据结构

列表

删除列表元素

1
del list[2]

Python列表脚本操作符

len([1,2,3])，结果为3

[1,2,3]+[4,5,6]，结果为[1,2,3,4,5,6]

['Hi']*4，结果为['Hi'.'Hi','Hi','Hi']

3 in [1,2,3]，结果为True

for x in [1,2,3]: print(x,end="")，结果为1 2 3

Py列表拼接

1
2
3
4
5
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

元组

元祖的元素不可修改。

元组使用小括号，列表使用方括号。

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下：

1
2
3
4
5
6
7
8
9
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)

结果为：

1
(12, 34.56, 'abc', 'xyz')

元组运算符

py表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
('Hi!',) * 4 (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print (x,) 1 2 3 迭代
发表更新学习2 分钟读完 (大约313个字)

python查漏补缺之zip()

描述

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
可以使用list()转换来输出列表。

若各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元祖解压为列表。

例1

1
2
3
4
5
6
7
a = [1,2,3]
c = [1,2,3,4]

zipped = zip(a,c)
l_zipped = list(zipped)
b = 3
print(type(zipped),type(l_zipped))

输出结果为：

1
2
<class 'zip'> <class 'list'>
[(1, 1), (2, 2), (3, 3)]

例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a = [
    [1,2],
    [3,4],
    [5,6]
]
c = [
    [5,6],
    [7,8],
    [9,10]
]
zipped = zip(a,c)
l_zipped = list(zipped)
b = 3
print(type(zipped),type(l_zipped))

print(l_zipped)

输出结果：

1
2
3
<class 'zip'> <class 'list'>
[([1, 2], [5, 6]), ([3, 4], [7, 8]), ([5, 6], [9, 10])]

例3

1
2
3
4
5
6
7
8
9
10
11
12
a = [1,2,3]
c = [1,2,3,4]

zipped = zip(a,c)
print(zipped,type(zipped))
accmulated = 1*[0]
accmulated = [x_c[0] + x_c[1] for x_c in zip(a,c)]
for i in zipped:
    print(i,type(i))
l_zipped = list(zipped)    # 转换为列表
#print(l_zipped)
print("accmulated:",accmulated)

输出结果：

1
2
3
4
5
<zip object at 0x7f3128d8d5c8> <class 'zip'>
(1, 1) <class 'tuple'>
(2, 2) <class 'tuple'>
(3, 3) <class 'tuple'>
accmulated: [2, 4, 6]

例4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = [
    [1,2],
    [3,4],
    [5,6]
]
c = [
    [5,6],
    [7,8],
    [9,10]
]
zipped = zip(a,c)
l_zipped = list(zipped)
accmulated = 1 *[0]
# 注：此处将zip(a,c)换为zipped则显示为空
for i in zip(a,c):
    print(i,type(i))
accmulated = [x_c[0] + x_c[1] for x_c in zip(a,c)]
print("accmulated:",accmulated)

输出结果：

1
2
3
4
5
([1, 2], [5, 6]) <class 'tuple'>
([3, 4], [7, 8]) <class 'tuple'>
([5, 6], [9, 10]) <class 'tuple'>
accmulated: [[1, 2, 5, 6], [3, 4, 7, 8], [5, 6, 9, 10]]

例5：矩阵的行列互换

1
2
3
a = [[1,2,3],[3,4,5]]
a1 = zip(*a)
print(list(a1))

输出结果：

1
[(1, 3), (2, 4), (3, 5)]
发表更新日常使用几秒读完 (大约82个字)

JupyterNotebook使用anaconda环境

  1. 首先，激活anaconda虚拟环境。
    激活环境
  2. 在该环境中安装ipykernel,pip或者conda都可以。
  3. 执行以下命令
    1
    python -m ipykernel install --user --name=paddle-cpu#那个环境的名字
  4. 在jupyter中查看
    结果
发表更新日常使用2 分钟读完 (大约293个字)

anaconda使用指南

创建新环境

conda create --name <env_name> <package_names>

  • 注意

    • env_name,即创建的环境名

    • package_names,即安装在环境中的包名。

      1. 如果要安装指定的版本号，则只需要在包名后面以=和版本号的形式的执行。如：conda create --name python2 python=2.7，即创建一个名为“python2”的环境，环境中安装版本为2.7的python。
      2. 如果需要在新创建的环境中创建多个包，则直接在后以空格隔开，添加多个包名即可。如：conda create -n python3 python=3.5 numpy pandas，即创建一个名为“python3”的环境，环境中安装版本为3.5的python，同时也安装了numpy和pandas。

    • --name可以替换为-n。

切换环境

针对Ubuntu18.04 conda4.6.14,命令为

1
conda activate <env_name>

退出环境

1
conda deactivate

显示已创建环境

1
conda info --envs

或

1
conda info -e

或

1
conda env list

获取当前环境中已安装的包信息

1
conda list

新的Anaconda会在终端中自动进入虚拟环境，使用以下命令即可解决

1
conda config --set auto_activate_base false

删除已安装的虚拟环境

1
2
conda env remove -n env_name

发表更新学习14 分钟读完 (大约2164个字)

python函数

可更改与不可更改对象

在python中，strings，tuples和numbers是不可更改的对象，而list，dict是可以修改的对象。

  • 不可变类型：变量a=5后再赋值a=10，这里实际是新生成一个int值对象10，再让a指向它，而5被丢弃，不是改变a的值，相当于新生成了a。
  • 可变类型：变量a=[1,2,3,4]后再赋值la[2]=5则是将list la的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python的参数传递：

  • 不可变类型：类似c++的值传递，如整数、字符串、元组。如fun(a)，传递的只是a的值，没有影响a对象本身。比如在fun(a)内部修改a的值，只是修改另一个复制的对象，不会影响a本身。
  • 可变类型：类似c++的引用传递，如列表，字典。如fun(la)，则是将la真正的传过去，修改后fun外部的la也会受影响。

python中一切都是对象，严格意义上不能说值传递还是引用传递，应该说传不可变对象和传可变对象。

python 传不可变对象实例

1
2
3
4
5
6
def ChangeInt(a):
    a = 10

b = 2
ChangInt(b)
print(b)

传可变对象实例
可变镀锡在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

1
2
3
4
5
6
7
8
9
10
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

参数

以下是调用函数时可使用的正式参数类型：

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必需参数
必需参数须以正确的顺序传入函数，调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：

1
2
3
4
5
6
7
8
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme()

关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。
以下实例在函数printme()调用时使用参数名：

1
2
3
4
5
6
7
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "菜鸟教程")

以下实例演示了函数参数的使用不需要使用指定顺序：

1
2
3
4
5
6
7
8
9
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入age参数，则使用默认值：

1
2
3
4
5
6
7
8
9
10
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

不定长参数
Python中的函数可以处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

1
2
3
4
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加上星号*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

1
2
3
4
5
6
7
8
9
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

还有一种就是参数带两个星号**基本语法如下：

1
2
3
4
def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了两个星号**的参数会以字典的形式导入。

1
2
3
4
5
6
7
8
9
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

声明函数时，参数中星号*可以单独出现，例如：

1
2
def f(a,b,*,c):
    return a+b+c

如果单独出现星号*后的参数必须用关键字传入。

匿名函数

python使用lambda来创建匿名函数。
所谓匿名，是指不再使用def语句这样的标准形式定义一个函数。

  • lambda只是一个表达式，函数体比def简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于c或c++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法
lambda函数的语法只包含一个语句，如下：

1
lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

1
2
3
4
5
6
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

变量作用域

Python中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

  • L(Local) 局部作用域
  • E(Enclosing) 闭包函数外的函数中
  • G(Global) 全局作用域
  • B(Built-in) 内置作用域（内置函数所在模块的范围）

以L -> E -> G -> B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

1
2
3
4
5
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一共名为builtin的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量：

1
2
>>> import builtins
>>> dir(builtins)

Python中只有模块(module)，类(class)以及函数(def、lambda)才会引入新的作用域，其它的代码块（如if/elif/else、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

1
2
3
4
5
>>> if True:
...  msg = 'I am from Runoob'
>>> msg
'I am from Runoob'
>>>

实例中msg变量定义在if语句块中，但外部还是可以访问的。
如果将msg定义在函数中，则它就是局部变量，外部不能访问。

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内部声明的变量名称都将被加入到作用域中。如下实例：

1
2
3
4
5
6
7
8
9
10
11
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

global和nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量num:

1
2
3
4
5
6
7
8
9
#!/usr/bin/python3
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

如果要修改嵌套作用域(enclosing作用域，外层非全局作用域)中的变量则需要nonlocal关键字，如下实例：

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
发表更新学习8 分钟读完 (大约1204个字)

安大考研复试题目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
有一个分数序列:2/1,3/2,5/3,8/5……求出这个数列的前n项之和.
*/
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
    int n=0;
    float sum=0;
    float a = 1.0;
    float b = 2.0;
    cin>>n;
    if(n<1||n>40)
        return 0;
    for(int i=0; i< n;i++){
        sum = sum + b/a;
        b = a + b;
        a = b - a;
    }
    cout<<sum<<endl;
    printf("%.6f",sum);
    return 0;
}

longestWord

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <algorithm>
#include <vector>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp> 
using namespace std;
int main(){
    char* str = new char[1000];
    string temp_str="";

    cin.getline(str,1000);


    temp_str = str;

    vector<string> ver_temp;
    boost::split(ver_temp,temp_str,boost::is_any_of(" "),boost::token_compress_on);
    //cout<<ver_temp.size()<<endl;
    for(vector<string>::iterator it=ver_temp.begin(); it != ver_temp.end();it++){
        //cout<<*it<<endl;
        for(int i=0; i <it->length();i++){
            (*it)[i] = tolower((*it)[i]);
        }
    }
    sort(ver_temp.begin(),ver_temp.end());

    string temp="";
    //cout<<"-----\n";
    for(int i=0; i<ver_temp.size();i++){
        //cout<<ver_temp[i]<<endl;
        
        if(ver_temp[i].length()>temp.length()){
            temp = ver_temp[i];
        }
    }
    cout<<temp<<endl;
    return 0;
}

2018

1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
 *第一题是斐波那契数列，给定一个函数： 
 *F(0)=0; F(1)=1; F(n)=F(n-1)+F(n-2),n>1
 *程序输入一个整数n,输入F(n)的值。
 *
 */

#include "iostream"
using namespace std;

int fri(int n)
{
	if(n==0)
		return 0;
	else if(n == 1)
		return 1;
	else
		return fri(n-2)+fri(n-1);

}
int main()
{
	for(int i=0;i<11;i++)
		cout<<fri(i)<<endl;
	return 0;
}

2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*================================================================
*   创建日期：2018年07月26日
*   描    述：
*
================================================================*/

#include <iostream>
#include "cstdio"
using namespace std;
typedef int ElemType;
#define MAXSIZE 100

struct sStack{
	ElemType data[MAXSIZE];
	int top;
};
typedef struct sStack seqStack;

void initial(seqStack &s){
	s.top = -1;
}
bool empty(seqStack &s){
	if(s.top == -1)
		return true;
	else
		return false;
}

ElemType top(seqStack S){
	if(empty(S))
		return -1;
	else
		return S.data[S.top];
}

bool full(seqStack S){
	if(S.top == MAXSIZE - 1)
		return true;
	else
		return false;
}
bool push(seqStack &S,ElemType x){
	if(full(S))
		return false;
	else{
		S.top++;
		S.data[S.top] = x;
		return true;
	}
}

ElemType pop(seqStack &S){
	if(empty(S))
		return -1;
	else
		return S.data[S.top--];
}
ElemType getBottomElemType(seqStack &S){
	if(empty(S))
		return -1;
	int x = -2;
	while(!empty(S)){
		x = S.data[S.top--];
	}
	return x;
}
void print(seqStack &S){
	while(empty(S)){
		cout<<pop(S)<<" ";
	}
	cout<<endl;
}
int main()
{
    int n =0;
    ElemType temp=0;

    seqStack fuck_s;
    initial(fuck_s);
    int test[3]={0};
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>test[i];
    }
    int i = 0;

    if(empty(fuck_s))
        push(fuck_s,test[i++]);
    cout<<top(fuck_s)<<endl;
    cout<<"----------\n";
    for(int i=1;i<n;i++)
    {
        if(top(fuck_s)>test[i]){
            pop(fuck_s);
            push(fuck_s,test[i]);

            cout<<"i-->"<<i<<" "<<test[i]<<endl;
        }
        else
            push(fuck_s,test[i]);

    }
    cout<<"========\n";
	while(!empty(fuck_s)){
		cout<<pop(fuck_s)<<"\n";
	}

//	ElemType test[10]={2,3,7};
//	ElemType temp;
//	seqStack fuck_s;
//	initial(fuck_s);
//	int i = 0;
//	int n = 0;
//	for(i = 0; i<3;i++)
//		push(fuck_s,test[i]);
//
//	//push(fuck_s,2);
//	cout<<"输入整数n: ";
//	cin>>temp;
//	while(!empty(fuck_s)){
//		if(top(fuck_s)>temp){
//			pop(fuck_s);
//			if(empty(fuck_s)){
//				push(fuck_s,temp);
//				break;
//			}
//		}
//		else{
//			push(fuck_s,temp);
//			break;
//		}
//		//cout<<pop(fuck_s)<<endl;
//	}
////	while(!empty(fuck_s)){
////		cout<<pop(fuck_s)<<"\n";
////	}
//	cout<<endl;
//	//print(fuck_s);
//	//cout<<top(fuck_s)<<endl;
	return 0;
}

3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*================================================================
*   创建日期：2018年07月27日
*   描    述：输入两个整数n，m每一次，第一个整数可以
*   		执行乘2,、减1、加1三种操作的任意一种，
*   		求n到m至少要多少次这样的操作。
*
================================================================*/


#include "iostream"
#include <cstdio>
#include <cstdlib>
using namespace std;

struct list{
    long n;
    int step;   //步数
    struct list *next;
};
int main(){
    long n,m,k;
    struct list *p,*p1,*p2,*p3,*pm;
    scanf("%ld %ld",&n,&m);

    //开辟节点,初始化
    p = (struct list *)malloc(sizeof(struct list));
    p ->n = n;
    p ->step = 1;
    p -> next = NULL;

    cout<<endl;
    //队尾节点
    pm = p;

    while(p!=NULL){

        cout<<"\n------------->\n";
        cout<<"p -> n: "<<p->n<<" p -> step: "<<p->step<<endl;
        k = p->n;
        if(k == m)
            break;

        //减操作
        p1 = (struct list*)malloc(sizeof(struct list));
        p1 -> n = k-1;
        p1 -> step = p->step+1;
        p1 -> next = NULL;
        cout<<"p1 -> n: "<<p1->n<<" p1 -> step: "<<p1->step<<endl;
        //入队尾
        pm -> next = p1;

        //加操作
        p2 = (struct list*)malloc(sizeof(struct list));
        p2 -> n = k + 1;
        p2 -> step = p->step +1;
        p2 -> next = NULL;
        p1 -> next = p2;    //入队，此时队尾为p2
        cout<<"p1 -> n: "<<p2->n<<" p1 -> step: "<<p2->step<<endl;

        //乘操作
        p3 = (struct list*)malloc(sizeof(struct list));
        p3 -> n = k * 2;
        p3 -> step = p -> step +1;
        p3 -> next = NULL;

        cout<<"p3 -> n: "<<p3->n<<" p3 -> step: "<<p3->step<<endl;
        p2 -> next = p3;
        pm = p3;    //此时队尾为p3

        p1 = p;
        p = p -> next;//此时p指向p后面的节点
//        cout<<p->n<<" "<<p->step<<endl;
        free(p1);   //释放原来的p节点

    }

    printf("%d\n",p->step -1);
    return 0;

}

2017

1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
1.输入10个正整数（有奇数也有偶数），要求输出其中的每个奇数，并输出奇数个数与奇数之和。
例如：输入：11,4,3,2,7,6,8,5,10,9
      输出：11 3 7 5 9
      NUM=5
      SUM=35
*/
#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
    int a[10]={0};
    int l_num = 0;
    int l_sum = 0;
    int n;
    for(int i=0;i<10;i++){
        cin>>n;
        if(n%2!=0){
            a[l_num++]=n;
            l_sum+=n;
        }
    }

    for(int i =0; a[i]!=0;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
    cout<<"NUM="<<l_num<<endl;
    cout<<"SUM="<<l_sum<<endl;


    return 0;
}

2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
找出1000之内的所有完数，并输出完数和它的所有因子（一个数恰好等于他的因子之后，称为完数，例如：6=1+2+3）
*/
#include <iostream>
#include <cmath>
using namespace std;

int getGongyin(int num){
    //cout<<sqrt(num)<<endl;
    int sum=0;
    for(int i = num-1; i>0; i-- )
    {
        if(num % i == 0 )
        {
            //cout<<i<<" ";
            sum+=i;
        }
    }
    if(sum==num){
        cout<<num<<" "<<sum<<endl; 
        for(int i = num-1;i>0;i--){
            if(num%i==0)
                cout<<i<<" ";
        }
        cout<<endl;
    }
}
int main(){
    int n;
    cin>>n;
    for(int i =1; i <1000;i++)
        getGongyin(i);

    
}

3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
由键盘输入一行仅由英文字母及空格组成的字符，编程实现（相邻单词之间用一个空格或多个空格隔开）
   （1）输出每个单词及其长度
   （2）输出最长的单词
例如：输入：I am a boy
      输出：I     1
            am   2
            a     1
            boy   3
            The longest word is:boy
*/
#include <iostream>
#include <cstdio>

using namespace std;
int main(){
    char a[1000];
    char b[30];

    int i,j,m=0,n=0;    //m记录最长的单词长度，j保存临时的单词长度，n记录最长单词的最后一位
    printf("请输入字符:");
    gets(a);

    //注：输入时最后要加空格
    //若临时单词长度大于m记录的单词长度，则将当前的单词长度赋给m，并记录当前单词的最后一位。
    for(i=0,j=0; a[i]!='\0';i++){
        if(a[i] != ' ')
        {
            j++;
            cout<<"i==> "<<i<<" j==> "<<j<<endl;
        }
        else if(j>m){
            cout<<"i--> "<<i<<" j--> "<<j<<" m-->"<<m<<endl;
            m=j;
            n=i;
            j=0;
        }
    }
    printf("最长的单词是：\n");
    for(i=0;i<m;i++)
        putchar(a[i+n-m]);
    return 0;
}

2016

1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
int main(){
    int a[10];

    for(int i = 0; i<10;i++)
        cin>>a[i];

    for(int i =0 ; i<10;i++){
        if(a[i]>=90)
            cout<<"A"<<endl;
        else if(a[i]>=80)
            cout<<"B"<<endl;
        else if(a[i]>=70)
            cout<<"C"<<endl;
        else if(a[i]>=60)
            cout<<"D"<<endl;
        else
            cout<<"E"<<endl;
    }
}

2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;

int main()
{
    int a[10];
    int sum=0;
    float aver=0;
    int count=0;
    for(int i =0;i<10;i++)
        cin>>a[i];

    for(int i =0;i<10;i++){
        if(a[i]%2==0){
            sum+=a[i];
            cout<<a[i]<<" ";
            count++;
        }
    }
    cout<<endl;
    cout<<"AVE="<<sum*1.0/count<<endl;
}

3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
using namespace std;
int main()
{
    int a[3][4]={0};

    for(int i=0; i<3;i++)
        for(int j=0;j<4;j++)
            cin>>a[i][j];

    int MAX = 0;
    int row,col;
    for(int i =0;i<3;i++){
        for(int j =0; j<4;j++){
//            cout<<a[i][j]<<" ";
            if(a[i][j]>MAX){
                MAX = a[i][j];
                row = i;
                col = j;
            }
        }
//        cout<<endl;
    }
    cout<<MAX<<" "<<row+1<<" "<<col+1<<endl;
    return 0;
}

2013

1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <cstdio>
#include <math.h>
using namespace std;
int main()
{
    long double a,b;

    /*
        e+002表示10的2次方。科学计数法，用e表示10，
        加号表示正整数次方， 减号，
        表示负整数次方，
        这里就是等于 123.456
    */
    double sum = 0;
    double temp = 0;
    for(int i = 0; ;i++){
        temp = pow(-1,i+1)*(1.0/(2*i-1));
        if(fabs(temp)<1e-5){
            cout<<fabs(temp)<<endl;
            break;
        }
        else{
            sum+=temp;
        }
    }
    cout<<sum<<endl;
//    printf("%lf\n",123.456e-2);
//    scanf("%le %lf",&a,&b);
//    printf("%.4lf\n",a+b);
    return 0;
}

2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
using namespace std;
int main()
{
    int a[3][3]={{3,4,-1},{2,1,3},{1,2,1}};
    int i,j;
    for(i = 0; i<3;i++)
    {
        for(j=0;j<3;j++){
            if(i>j){
                a[i][j] += a[j][i];
                a[j][i] = 0;
            }
        }
    }

    for(i =0;i<3;i++){
        for(j=0;j<3;j++){
            cout<<a[i][j]<<" ";
        }
        cout<<endl;
    }


}

3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
using namespace std;

void quickSort(int a[],int left,int right){
    int i,j,t,temp;
    if(left>right)
        return;

    temp = a[left];
    i = left;
    j = right;
    while(i!=j){

        while(a[j]>= temp && i<j)
            j--;
        while(a[i]<=temp&& i<j)
            i++;

        if(i<j){
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    a[left] = a[i];
    a[i] = temp;

    quickSort(a,left,i-1);
    quickSort(a,i+1,right);
    return;
}
int main()
{
    int b[100];
    int N=0;
    int k=0;
    cout<<"输入整数n：";
    cin>>N;
    cout<<"输入整数k:";
    cin>>k;

    cout<<"输入数组：";
    for(int i=0;i<N;i++)
        cin>>b[i];

    quickSort(b,0,N-1);
    for(int i =0;i<N;i++){
        cout<<b[i]<<" ";
    }
    cout<<endl;
    for(int i = 0;i<k;i++)
    {
        cout<<b[i]<<" "<<b[N-i-1]<<endl;
    }
    cout<<endl;
    return 0;
}

发表更新日常使用5 分钟读完 (大约739个字)

linux命令记录

sed命令

直接编辑文件选项-i,会匹配file文件中每一行的第一个book替换为books：

1
sed -i 's/book/books/g' file

vim替换

替换当前行：
:s/foo/bar/g
全文：
:%s/foo/bar/g

vim打开折叠

:zc折叠，只折叠最外层的折叠
:zC对所在范围内所有嵌套的折叠点进行折叠，包括嵌套的所有折叠
:zo展开折叠，只展开最外层的折叠
:zO对所在范围内所有嵌套的折叠点展开，包括嵌套折叠
:[z到当前打开的折叠的开始处
:]z到当前打开的折叠的末尾处

vim查找

查找字符串super
:/super或者:?super
两者的区别是前者从上往下搜索，后者是从下往上搜索
并且可以通过 n 或 N 进行上一个或下一个的匹配

vim消除搜索后的关键字高亮

输入:noh

压缩与解压

.tar.gz文件

压缩

1
tar -zcvf FileName.tar.gz DirName       # 将DirName和其下所有文件（夹）压缩

解压

1
tar -zxvf FileName.tar.gz               # 解压

解压到指定路径

1
tar -C DesDirName -zxvf FileName.tar.gz # 解压到目标路径

.tar文件

打包

仅打包，并非压缩

1
tar -cvf FileName.tar DirName # 将DirName和其下所有文件（夹）打包

解包

1
tar -xvf FileName.tar         # 解包

shell脚本接受命令行参数

1
2
3
# test.sh

ls $1

$1：是第一个参数

$0：是文件本身

结果：

image-20210725095824865

du查看文件或文件夹的大小

1
du -h --max-depth=1

如果当前目录下文件和文件夹很多，使用不带参数的du命令，可以循环列出当前目录下所有文件和文件夹所使用的空间。文件多时就会很乱，可以使用参数--max-depth=指定深入目录的层数；

使用du -h --max-depth=0命令，可以查看当前目录已使用的总空间大小及当前目录已使用的总空间大小；

使用du -h --max-depth=1命令，可以查看当前目录已使用的总空间大小及当前目录下一级文件和文件夹各自使用的总空间大小。

查看端口号

1
netstat -apn

查看网络状态，a 是 all ，p 显示程序， n是显示程序对应的端口号

使用管道操作符可以查找端口号 

1
netstat -apn | grep 8080

查看进程信息

1
ps -aux

杀死进程

1
kill -9 3306 // 强制杀掉进程号3306

查找文件中的字符串

1
grep -e "fuck" text.txt

查看文件

1
find ./ -name test.txt // 在当前目录下查找名称带有text.txt的文件

awk命令

pass

添加用户

1
sudo adduser username

然后按提示操作。

添加root权限

1
sudo vim /etc/sudoers

修改如下文件：

1
2
3
# User privilege specification
root    ALL=(ALL:ALL) ALL
lrr     ALL=(ALL:ALL) ALL
关注我

链接

分类

最新文章

标签

BFS3
DFS3
Java面经1
algorithm4
android1
bfs2
c++9
dfs7
dp1
dpLearning13
java1
jvm9
ordered-map1
python8
spring6
sql3
tools16
二分查找1
二叉树13
位运算10
傻屌题1
分治2
分治算法2
动态规划6
双指针7
哈希1
哈希表2
回溯5
堆2
堆排序1
多线程1
字符串5
总结1
找规律2
指针1
排序9
数字1
数据库1
数组9
最短路径1
查找2
栈9
树12
测试6
测试知识1
滑动窗口1
自动机1
计算机基础2
计算机网络1
计算机网络基础1
论文阅读10
设计1
贪心算法3
较难13
递归6
链表14
队列1
需要review8
面试记录1
×