第一课第四周作业

作业提纲

  • 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

阅读更多

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 迭代

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)]

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()

安大考研复试题目

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;
}

安卓界面跳转

  • intent界面跳转与传数据

    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
    package com.example.python.myapp;

    import android.content.Intent;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;

    public class All_single_Activity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate( savedInstanceState );
    setContentView( R.layout.layout4 );


    //接受数据
    Intent intent4 = getIntent();
    String name = (String)intent4.getSerializableExtra( "heroName" );
    Hero hero = new Hero(name);
    TextView info = (TextView)findViewById( R.id.all_hero_info );
    String story = hero.getHeroStory(name);
    info.setText( story );

    //返回逻辑上一页
    Button btn = (Button)findViewById( R.id.all_back_home );
    btn.setOnClickListener( new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    Intent intent = new Intent( All_single_Activity.this,DetailActivity.class );
    All_single_Activity.this.startActivity( intent );
    }
    } );
    }
    }
  • listview与监听

    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
    package com.example.python.myapp;

    import android.content.Intent;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.AdapterView;
    import android.widget.ArrayAdapter;
    import android.widget.Button;
    import android.widget.ListView;

    public class DetailActivity extends AppCompatActivity implements AdapterView.OnItemClickListener {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.detail);

    ListView listView = (ListView)findViewById(R.id.list_item);
    //适配器
    listView.setAdapter(new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,hero));

    //监听
    listView.setOnItemClickListener(this);


    //返回主页
    Button back_home = (Button)findViewById(R.id.all_back_home);
    back_home.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    Intent intent = new Intent(DetailActivity.this,MainActivity.class);
    DetailActivity.this.startActivity(intent);
    }
    });
    }

    private static final String[] hero = new String[]{
    "猎空",
    "小美",
    "温斯顿",
    "D.VA",
    "布丽吉塔"
    };
    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    ListView item = (ListView)findViewById( R.id.list_item );
    String str = item.getItemAtPosition( position ).toString();
    // Toast.makeText(DetailActivity.this,str,Toast.LENGTH_LONG).show();

    Intent intent = new Intent( DetailActivity.this,All_single_Activity.class );
    Bundle mExtra = new Bundle();
    mExtra.putSerializable( "heroName",str );
    intent.putExtras( mExtra );
    DetailActivity.this.startActivity( intent );
    }
    }

插入排序

1.算法

插入排序由N-1趟排序组成。对于P = 1 趟到 P = N - 1趟,插入排序保证从位置0到位置P上的元素为已排序状态。插入排序利用了这样的事实:位置0到位置 P - 1上的元素是已排过序的。
下表表达了一般的方法。在第P趟,我们将位置P上的元素想做移动到它在前P+1个元素中的正确位置上。下面的程序实现了该想法。第2行到第5行实现数据移动而没有明显使用交换。位置P上的元素存于Tmp,而(在位置P之前)所有更大的元素都被向右移动一个位置。然后Tmp被置于正确的位置上。这种方法与实现二叉堆时所用到的技巧相同。

初始 34 8 64 51 32 21 移动的位置
在p=1之后 8 34 64 51 32 21 1
在p=2之后 8 34 64 51 32 21 0
在p=3之后 8 34 51 64 32 21 1
在p=4之后 8 32 54 51 64 21 3
在p=5之后 8 21 32 34 51 64 4
1
2
3
4
5
6
7
8
9
10
11
12
13
void InsertionSort(ElementType A[], int N)
{
int j, P;

ElementType Tmp;
for( P = 1; P < N; P++) //1
{
Tmp = A[P]; //2
for( j = P; j > 0 && A[ j-1 ] > Tmp; j--) //3
A[j] = A[j-1]; //4
A[j] = Tmp; //5
}
}

2.插入排序的分析

由于嵌套循环的每一个都花费N次迭代,因此插入排序为O(N2),而且这个界是精确的,因为以反序输入可以达到该界。精确计算指出对于P的每一个值,第4行的测试最多执行P+1次。对所有的P求和,得到总数为
SUM = 2 + 3 + 4 + ... + N = O(N<sup>2</sup>)
另一方面,如果输入数据已排序,那么运行时间为O(N),因为内层for循环的检测是立即判定不成立而终止。事实上,如果输入几乎被排序,那么插入排序将运行得很快。

c++学习记录七:多态性:对象独立性(抽象类,虚函数)

(本文来自c++简明教程)
对象要想真正有用,就必须具有独立性。每个对象都应该相当于一台微型计算机,能发送并响应消息。只要一个新的对象类型使用了恰当的接口,你就应该能够把它“插接”到现有的软件上。
从字面意义上看多态性意味着“多种形式”。在最基本的级别上,它意味着以多种方式实现相同的操作。它最重要的意义在于,无需更改使用了一个对象的代码,就能将对象替换成另一个对象类型,而程序仍能正常工作。
打个比方。你的子处理软件能和你购买的任何打印机正确地交互。你甚至可以在5年之后,拔除用旧的打字机,接上一台当前尚未问世的打字机。今天写字处理软件的人不需要知道所有规格的打印机的详细信息。
这正是“多态性”存在的理由:使用所有软件对象都能像硬件组件那样工作,它们能协同工作,并根据需要进行置换。旧的软件能顺利连接较新的软件······那自是“重用性”的含义。

阅读更多

c++学习记录六:继承

(本文来自c++简明教程)
类最突出的一个特性就是“子类化”(subclassing),也就是一个类从以前定义好的一个类继承它的成员。处于几方面的原因,这个特性显得非常重要。
第一个原因是子类化处理允许你定制现有的软件。你可以拿到别人创建的一个类,在上面添加自己独有的新功能。还可以覆盖类的任何或者全部功能。这样一来,类就具有了扩展性和重用性(我保证这是你在本章见到的最后两个专业术语)。
听起来似乎很不错……有时的确如此!但是,考虑到本章要讨论的一些技术原因,你的工作并非总是那么轻松。最起码,你必须修订所有构造函数。
使用一个继承层次结构和创建接口时,也需要用到“子类化”技术,详情将在下一章讨论。

阅读更多