2014华为校园招聘机试整理及本人华为面试经历

整理网２０１４华机试题十网页资料时道题均进行验证题目进行更修正希者帮助

1．第题题目概输入整型数组求数组数数例输入1234输出5输入数时候数数该数例输入1输出2外数组长度超50
#include
main()
{
int num[50]{0}
int in

printf(请输入整型数组长度(1~50)：)
scanf(d&n)

printf(请输入整型数组元素：)
for (i0i {
scanf(d&num[i])
}

int min_numnum[0]
int max_numnum[0]
for(int j0j {
if(max_num max_numnum[j]
else if(min_num>num[j])
min_numnum[j]
}
int summin_num+max_num
printf(数组中值：d＼nsum)
return 0
}

2．求两长长整型数输出例输入1233333333333333 3111111111111111111111111输出
#include
#include
#include
main()
{
char *num1*num2 两长长整型数
char *sum
int temp
int len_num1len_num2 两长长整型数长度
int len_maxlen_min
num1(char*)malloc(sizeof(char))
num2(char*)malloc(sizeof(char))
printf(输入两长长整型数：)
scanf(snum1)
printf(输入两长长整型数：)
scanf(snum2)
len_num1strlen(num1)
len_num2strlen(num2)
len_max(len_num1>len_num2) len_num1len_num2
len_min(len_num1 int len_max1len_max
sum(char*)malloc(sizeof(char)*len_max)
memset(sum0x00len_max+1)切忌初始化
for(len_num1>0&&len_num2>0len_num1len_num2)
{
sum[len_max]((num1[len_num11]＇0＇)+(num2[len_num21]＇0＇))
}
if(len_num1>0)
{
sum[len_max]num1[len_num1 1 ]＇0＇
len_num1
}
if(len_num2>0)
{
sum[len_max]num1[len_num2 1]＇0＇
len_num2
}
for(int jlen_max1j>0j) 实现进位操作
{
tempsum[j]＇0＇
if(sum[j]>10)
{
sum[j1]+sum[j]10
sum[j]10
}
}
char *outsum(char*)malloc(sizeof(char)*len_max1)
j0
while(sum[j]0) 跳出头部0元素
j++
for(int m0m outsum[m]sum[j]+＇0＇
outsum[m]＇＼0＇
printf(输出两长长整型数s＼noutsum)
return 0
}

3通键盘输入串写字母(a~z)组成字符串请编写字符串滤程序字符串中出现相字符非首次出现字符滤掉
字符串abacacde滤结果abcde
求实现函数：
void stringFilter(const char *pInputStr long lInputLen char *pOutputStr)
输入 pInputStr： 输入字符串
lInputLen： 输入字符串长度
输出 pOutputStr： 输出字符串空间已开辟输入字符串等长
#include
#include
#include
void stringFilter(const char *p_str long len char *p_outstr)
{
int array[256]{0}
const char *tmp p_str
for(int j0j {
if(array[tmp[j]]0)
*p_outstr++ tmp[j]
array[tmp[j]]++
}
*p_outstr ＇＼0＇
}

void main()
{
char *str cccddecc
int len strlen(str)
char * outstr (char *)malloc(len*sizeof(char))
stringFilter(strlenoutstr)
printf(s＼noutstr)
free(outstr)
outstr NULL
}

4通键盘输入串写字母(a~z)组成字符串请编写字符串压缩程序字符串中连续出席重复字母进行压缩输出压缩字符串
压缩规：
1 仅压缩连续重复出现字符字符串abcbc连续重复字符压缩字符串abcbc
2 压缩字段格式字符重复次数+字符例：字符串xxxyyyyyyz压缩成3x6yz

求实现函数：
void stringZip(const char *pInputStr long lInputLen char *pOutputStr)

输入 pInputStr： 输入字符串
lInputLen： 输入字符串长度
输出 pOutputStr： 输出字符串空间已开辟输入字符串等长
#include
#include
#include

void stringZip(const char *p_str long len char *p_outstr)
{
int count1
for(int i0i {
if(p_str[i]p_str[i+1])
{
count++
}
else
{
if(count>1)
{
*p_outstr++ count +＇0＇
*p_outstr++ p_str[i]
}
else
{
*p_outstr++ p_str[i]
}
count 1注意位置
}
}
*p_outstr ＇＼0＇
}

void main()
{
char *str cccddecc
printf(压缩前字符串：s＼nstr)
int len strlen(str)
char * outstr (char*)malloc(len*sizeof(char))
stringZip(strlenoutstr)
printf(压缩字符串：s＼noutstr)
free(outstr)
outstr NULL
}
5通键盘输入100正整数加减运算式请编写程序输出运算结果字符串
输入字符串格式：操作数1 运算符 操作数2操作数运算符间空格隔开

补充说明：
1 操作数正整数需考虑计算结果溢出情况
2 输入算式格式错误输出结果0

求实现函数：
void arithmetic(const char *pInputStr long lInputLen char *pOutputStr)

输入 pInputStr： 输入字符串
lInputLen： 输入字符串长度
输出 pOutputStr： 输出字符串空间已开辟输入字符串等长
#include
#include
#include
void arithmetic(const char *input long len char *output)
{
char s1[10]
char s2[10]
char s3[10]
int cnt 0
int len_inputstrlen(input)
for(int i0i {
if(input[i]＇ ＇)
cnt++
}

if(cnt2)
{
*output++ ＇0＇
*output ＇＼0＇
return
}

sscanf(inputs s ss1s2s3)
if(strlen(s2)1||(s2[0]＇+＇&&s2[0]＇＇))
{
*output++ ＇0＇
*output ＇＼0＇
return

}

int len_s1strlen(s1)
for(i0i {
if(s1[i]<＇0＇||s1[i]>＇9＇)
{
*output++ ＇0＇
*output ＇＼0＇
return
}
}

int len_s3strlen(s3)
for(i0i {
if(s3[i]<＇0＇||s3[i]>＇9＇)
{
*output++ ＇0＇
*output ＇＼0＇
return
}
}

int x atoi(s1)
int y atoi(s3)
if(s2[0]＇+＇)
{
int result x+y
itoa(resultoutput10)
}
else if(s2[0]＇＇)
{
int result xy
itoa(resultoutput10)
}
else
{
*output++ ＇0＇
*output ＇＼0＇
return

}

}
void main()
{
char str[] {10 23}
char outstr[10]
int len strlen(str)
arithmetic(strlenoutstr)
printf(s＼nstr)
printf(s＼noutstr)
}

6组（n）围成圈某开始数第三出列接着开始数终输出终出列
（约瑟夫环数学应问题：已知n（编号123n分表示）围坐张圆桌周围编号k开始报数数m出列1开始报数数m出列规律重复直圆桌周围全部出列）
#include
#include
#include
#include

typedef struct Node
{
int data
struct Node *next
}LinkList

LinkList *create(int n)
{
LinkList *p*q*head
int i1
p(LinkList*)malloc(sizeof(LinkList))
p>datai
headp

for(i1i {
q(LinkList*)malloc(sizeof(LinkList))
q>datai+1
p>nextq
pq
}
p>nexthead 链表尾连接链表头形成循环链表
return head
free(p)
pNULL
free(q)
qNULL
}

void deletefun(LinkList *Lint m)
{
LinkList *p*q*temp
int i
pL

while(p>nextp)
{
for(i1i {
qp
pp>next
}
printf(5dp>data)
tempp
q>nextp>next
pp>next
free(temp)
}
printf(5d＼np>data)
}

int main()
{
int n7m3
LinkList *head1
head1create(n)
deletefun(head1m)
return 0
}
7输入串字符包含010找出中数字数字（止）输出剩余数字数 输入 3345677
#include
#include
#include

void main()
{
char str[100]
printf(输入组字符串：＼n)
scanf(s&str)

int lenstrlen(str)
int array[100]
int count0
for(int i0i {
if(str[i]>＇0＇&&str[i]<＇9＇)
array[count++]str[i]＇0＇

}
array[count]＇＼0＇
int resultcount
int minarray[0]
int maxarray[0]
for(int j0j {
if(max maxarray[j]
else if(min>array[j])
minarray[j]
}
for(int k0k {
if(array[k]min)
result
if(array[k]max)
result
}
printf(d＼nresult)
}
8输入组身高170190间（5身高）较身高差选出身高差两身高身高差相选均身高高两身高输出
输入 170 181 173 186 190 输出 170 173
#include
#include
#define N 5

int main()
{
int Height[N]
int dmin
int H1H2
int ijtemp

printf(请输入组身高170190间数（5）＼n)
for(int k0k scanf(d&Height[k])
printf(＼n)

for(i0i for(j1jHeight[j]j++)
{
tempHeight[j1]
Height[j1]Height[j]
Height[j]temp
}

H1Height[0]
H2Height[1]
dminH2H1
for(int m2m {
if(Height[m]Height[m1] {
H1Height[m1]
H2Height[m]
dminHeight[m]Height[m1]
}
}
printf(身高差两身高＼n)
printf(dd＼nH1H2)
return 0
}
9 删子串原串中相子串删掉少返回子串数
#include
#include
#include
#include
int delete_sub_str(const char *strconst char *sub_strchar *result)
{
assert(str NULL && sub_str NULL)
const char *p*q
char *t*temp
p str
q sub_str
t result
int ncount 0
n strlen(q)
temp (char *)malloc(n+1)
memset(temp0x00n+1)
while(*p)
{
memcpy(temppn)
if(strcmp(tempq) 0 )
{
count++
memset(temp0x00n+1)
p p + n
}
else
{
*t *p
p++
t++
memset(temp0x00n+1)
}
}
free(temp)
return count
}
void main()
{
char s[100] {＼0’}
int num delete_sub_str(123abc12de234fg1hi34j123k123s)
printf(The number of sub_str is d＼r＼nnum)
printf(The result string is s＼r＼ns)
}
10 求编程实现述高精度十进制加法求实现函数：
void add (const char *num1 const char *num2 char *result)
输入num1：字符串形式操作数1果操作数负num1[0]符号位＇＇
num2：字符串形式操作数2果操作数负num2[0]符号位＇＇
输出result：保存加法计算结果字符串果结果负result[0]符号位
#include
#include
#include

void move(char *str int length) 移字母前符号
{
if(str[0] ＇＇)
return
int i
for(i 0 i < length1 i++)
str[i] str[i+1]
str[i] ＇＼0＇
}

int remove_zero(char *result int length)
{
int count 0
for(int i length1 i > 0 i) 开始移0直遇非0数字初位置0予判断
{
if(result[i] ＇0＇)
{
result[i] ＇＼0＇
count++
}else
return lengthcount
}
return length count
}

void reverse(char *result int length) 字符串倒转
{
char temp
for(int i 0 i < (length1)2 i++)
{
temp result[i]
result[i] result[length1i]
result[length1i] temp
}
}

int real_add(char *str1 char *str2 char *result const bool flag)
{
int len1 strlen(str1)
int len2 strlen(str2)
int n1 n2 another 0 another表示进位
int cur_rs 0 表示result前位数
int i j
int curSum
for(i len11 j len21 i > 0 && j > 0 i j)
{
n1 str1[i] ＇0＇
n2 str2[j] ＇0＇
curSum n1 + n2 + another
result[cur_rs++] curSum 10 + ＇0＇
another curSum 10
}

if(j < 0)
{
while(i > 0) 遍历str1剩余位
{
n1 str1[i] ＇0＇
curSum n1 + another
result[cur_rs++] curSum 10 + ＇0＇
another curSum 10
}
if(another 0) 果进位未加
result[cur_rs++] another + ＇0＇
}
else
{
while(j > 0)
{
n2 str2[j] ＇0＇
curSum n2 + another
result[cur_rs++] curSum 10 + ＇0＇
another curSum 10
}
if(another 0)
result[cur_rs++] another + ＇0＇
}

result[cur_rs] ＇＼0＇

cur_rs remove_zero(result cur_rs)
if(flag)
{
result[cur_rs++] ＇＇
result[cur_rs] ＇＼0＇
}
reverse(result strlen(result))
return cur_rs
}


int real_minus(char *str1 char *str2 char *result) str1减str2
{
char big[100] small[100]
int big_len sml_len

int len1 strlen(str1)
int len2 strlen(str2)
bool flag false 标记str2否str1

if(len1 < len2)
flag true
else if(len1 len2)
{
if(strcmp(str1 str2) 0)
{
result[0] ＇0＇
result[1] ＇＼0＇
return 1
}else if(strcmp(str1str2) < 0)
flag true
}

if(flag) str1str2交换确保str1指值中较者通flag确定前面加号
{
char *temp str1
str1 str2
str2 temp
len1 strlen(str1)
len2 strlen(str2)
}

int n1 n2 another 0 another表示否位
int i j
int cur_rs 0
int curMinus

for(i len11 j len21 i>0 && j>0 ij)
{
n1 str1[i] ＇0＇
n2 str2[j] ＇0＇
if(n1 > n2+another)
{
result[cur_rs++] (n1n2another) +＇0＇
another 0
}
else
{
result[cur_rs++] (n1+10n2another) + ＇0＇
another 1
}
}

while(i > 0)
{
n1 str1[i] ＇0＇
if(another 0)
{
n1 another
another 0
}
result[cur_rs++] n1 + ＇0＇
}

result[cur_rs] ＇＼0＇
cur_rs remove_zero(result cur_rs)
if(flag)
{
result[cur_rs++] ＇＇
result[cur_rs] ＇＼0＇
}
reverse(result cur_rs)

return cur_rs
}

void addi(const char *num1 const char *num2 char *result)
{
int len1 strlen(num1)
int len2 strlen(num2)
int rs_len
if(len1 || len2)
return
char str1[100] str2[100]
strncpy(str1 num1 len1)
str1[len1] ＇＼0＇
strncpy(str2 num2 len2)
str2[len2] ＇＼0＇

if(str1[0] ＇＇ && str2[0] ＇＇)
{
move(str1 len1)
move(str2 len2)
rs_len real_add(str1 str2 result false)
}else if(str1[0] ＇＇)
{
move(str1 len1)
rs_len real_minus(str2 str1 result)
}
else if(str2[0] ＇＇)
{
move(str2 len2)
rs_len real_minus(str1 str2 result)
}else
rs_len real_add(str1 str2 result true)
}

int main(int argc char *argv[])
int main()
{
char num1[100]num2[100]
printf(请输入两整型数：＼n)
scanf(ssnum1num2)

char result[100]
memset(result 0 100)
addi(num1num2 result)
printf(s＼n result)

return 0
}
11 描述：10学生考完期末考试评卷完成A老师需划出格线求：
(1) 格线10倍数
(2) 保证少60学生格
(3) 果学生高60分格线60分
输入：输入10整数取值0~100
输出：输出格线10倍数
#include

void bubblesort(int arr[])
{
int ijtemp
for(i0i<10i++)
for(j0j<9i&&arr[j]>arr[j+1]j++)
{
temparr[j]
arr[j]arr[j+1]
arr[j+1]temp
}
}

int GetPassLine(int a[])
{
bubblesort(a)
if(a[0]>60)
return 60
else
return (((int)a[4]10)*10)
}

main()
{
int a[10]{0}
int result
printf(请机输入10成绩（0100）：＼n)
scanf(dddddddddd&a[0]&a[1]&a[2]&a[3]&a[4]&a[5]&a[6]&a[7]&a[8]&a[9])
printf(＼n)
resultGetPassLine(a)
printf(格线d＼nresult)
return 1
}

12 描述：条长廊里次装n(1 ≤ n ≤ 65535)盏电灯头尾编号123…n1n盏电灯拉线开关控制开始电灯全部关着
n学生长廊穿第学生号码1倍数电灯开关拉接着第二学生号码2倍数电灯开关拉接着第三学生号码3倍数电灯开关拉继续第n学生号码n倍数电灯开关拉n学生规定走完长廊里电灯盏亮着注：电灯数学生数致
输入：电灯数量
输出：亮着电灯数量
样例输入：3
样例输出：1

#include
#define Max_Bubl_Num 65535

int GetLightLampNum(int n)
{
int BublNum[Max_Bubl_Num]{0} 0表示灯灭1表示灯亮
unsigned int ij
unsigned int count0
for(i1i for(jij {
BublNum[j1]+1
BublNum[j1]BublNum[j1]2
}

for(int k0k {
if(BublNum[k]1)
count++
}
return count
}
int main()
{
int nresult
printf(请输入灯数量（165535）＼n)
scanf(d&n)
resultGetLightLampNum(n)
printf(亮灯数量d＼nresult)
return 0
}
13 描述：已知2条铁线路中A环线B东西线路线路双站点名分两条线交叉换点T1T2表示编写程序意输入两站点名称输出坐铁少需车站数量（含输入起点终点换站点计算次）
铁线A（环线）车站：A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
铁线B（直线）车站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
输入：输入两站名
输出：输出少站数含输入起点终点换站点计算次
输入样例：A1 A3
输出样例：3
#include
#include
#include
#include
using namespace std

#define MAX 35
#define SUBWAY_A 20
#define SUBWAY_B 15
typedef struct node{
int adjvex
struct node *next
}edgenode
typedef struct{
char name[10]
bool flag
edgenode *link
}vexnode

const char subway_name1[SUBWAY_A][10]{A1A2A3A4A5A6A7A8A9T1A10A11A12A13T2A14A15A16A17A18}
const char subway_name2[SUBWAY_B][10]{B1B2B3B4B5B6B7B8B9B10B11B12B13B14B15}
void creat(vexnode ga[]){
int i
edgenode *p
for(i0i ga[i]linkNULL
ga[i]flagtrue
if(i else strcpy(ga[i]namesubway_name2[i20])
}
A铁建邻接表
for(i1i p(edgenode*)malloc(sizeof(edgenode))
p>adjvexi1
p>nextNULL
ga[i]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexi+1
p>nextNULL
ga[i]link>nextp
if(i9){
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+4
p>nextNULL
ga[i]link>next>nextp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+5
p>nextNULL
ga[i]link>next>next>nextp
}
else if(i14){
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+9
p>nextNULL
ga[i]link>next>nextp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+10
p>nextNULL
ga[i]link>next>next>nextp
}
}
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A1
p>nextNULL
ga[0]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvex1
p>nextNULL
ga[0]link>nextp

p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A2
p>nextNULL
ga[SUBWAY_A1]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvex0
p>nextNULL
ga[SUBWAY_A1]link>nextp

B铁建邻接表
for(i1i if(i4||i5||i9||i10) continue
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+i1
p>nextNULL
ga[i+SUBWAY_A]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+i+1
p>nextNULL
ga[i+SUBWAY_A]link>nextp
}
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+3
p>nextNULL
ga[SUBWAY_A+4]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvex9
p>nextNULL
ga[SUBWAY_A+4]link>nextp

p(edgenode*)malloc(sizeof(edgenode))
p>adjvex9
p>nextNULL
ga[SUBWAY_A+5]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+6
p>nextNULL
ga[SUBWAY_A+5]link>nextp

p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+8
p>nextNULL
ga[SUBWAY_A+9]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvex14
p>nextNULL
ga[SUBWAY_A+9]link>nextp

p(edgenode*)malloc(sizeof(edgenode))
p>adjvex14
p>nextNULL
ga[SUBWAY_A+10]linkp
p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+11
p>nextNULL
ga[SUBWAY_A+10]link>nextp

p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+1
p>nextNULL
ga[SUBWAY_A]linkp

p(edgenode*)malloc(sizeof(edgenode))
p>adjvexSUBWAY_A+SUBWAY_B2
p>nextNULL
ga[SUBWAY_A+SUBWAY_B1]linkp
印邻接节点
for(i0i printf(sga[i]name)
edgenode *s
sga[i]link
while(sNULL){
printf(>sga[s>adjvex]name)
ss>next
}
printf(＼n)
}

}
int main(){
vexnode ga[MAX]
creat(ga)
int i
char str[2][10]
while(scanf(ssstr[0]str[1])EOF){
int temp0
for(i0i ga[i]flagtrue
if(strcmp(str[0]ga[i]name)) tempi
}
queueq
qpush(ga[temp])
ga[temp]flagfalse
int count0
int start0
int end1
bool find_flagfalse
while(qempty()){
if(find_flag) break
count++
printf(************************＼n)
printf(第d层搜索：count)
int temp_endend
while(start printf(s qfront()name)
if(strcmp(qfront()namestr[1])){
find_flagtrue
break
}
edgenode *s
sqfront()link
while(sNULL){
if(ga[s>adjvex]flag){
qpush(ga[s>adjvex])
ga[s>adjvex]flagfalse
end++
printf(s ga[s>adjvex]name)
}
ss>next
}
qpop()
start++
}
printf(＼n)
}
printf(d＼ncount)
}
return 0
}
14 字串转换
问题描述：
输入字符串（字符串仅包含写字母a’z’）规循环转换输出：a>bb>c…y>zz>a输入字符串连续出现两字母相时字母需连续转换2次例：aa 转换 bczz 转换 ab连续相字母超两时第三出现字母第次出现算
求实现函数：
void convert(char *inputchar* output)
输入 char *input 输入字符串
输出 char *output 输出字符串
返回
#include
#include
#include

void convert(char *inputchar* output)
{
if(inputNULL)
return
char temp＇＼0＇
int len_inputstrlen(input)
int i
int flag0

for(i0i {
if(input[i]temp)
{
output[i](input[i]＇a＇+1)26+＇a＇
tempinput[i]
flag1
}
else
{
if(flag1)
{
output[i](input[i]＇a＇+2)26+＇a＇
tempinput[i]
flag0
}
else
{
output[i](input[i]＇a＇+1)26+＇a＇
tempinput[i]
flag1
}
}
}
output[i]＇＼0＇
}

void main()
{
char *inputxyz
char output[256]
scanf(sinput)
convert(inputoutput)
printf(s＼noutput)
}
15 定字符串中找出单词（ 单词写字母写字母字符构成非字母字符视单词间隔空格问号数字等等外单字母算单词）找单词长度进行降序排序（排序时果长度相出现序进行排列）然输出新字符串中果某单词重复出现次输出次果整输入字符串中没找单词请输出空串输出单词间空格隔开单词加空格
求实现函数：
void my_word(charinput[] char output[])
输入 char input[] 输入字符串
输出 char output[]输出字符串
返回
#include
#include
#include

void my_word(char input[]char output[])
{
char *p
char *temp
char *word[10]
int len_inputstrlen(input)
int ij
char except[]
char *blank
i0
for (i0i {
if (input[i]<＇A＇ || (input[i]>＇Z＇&&input[i]<＇a＇) || input[i]>＇z＇)
{
input[i]＇＇
}
}

j0
*保存取出单词*
p strtok(inputexcept)
while(NULLp)
{
word[j++]p
p strtok(NULLexcept)
}
for(i0i<5i++)
printf(sword[i])
*单词长度降序排序泡法*
for (i0i<5i++)
{
for (j1j<5ij++)
{
if(strlen(word[j1]) {
tempword[j]
word[j]word[j1]
word[j1]temp
}
}

}
*删相单词*
for (i0i<5i++)
{
for(ji+1j<5j++)
{
if(strcmp(word[i]word[j])0)
word[j]＼0
}
}
*单词连接起输出*
for (j0j<5j++)
{
if (0j)
{
strncpy(outputword[j]strlen(word[j])+1)
}
else
{
strcat(outputblank)
strcat(outputword[j])
}
}
return
}
int main()
{

char input[] some local buses some1234123drivers
printf(筛选前字符串s＼ninput)
char output[30]
my_word(inputoutput)
printf(筛选字符串soutput)
printf(＼n)
return 0
}
１６ 数组中数字两两相找出该数字：
int findUnique(int* a int len)
{
int i 1
int temp a[0]
for( i < len i++)
{
temp temp ^ a[i]
}
printf(d temp)
}
17 题目二：数组中数字两两相两找出两：

#include

int a[] {11243325}

int findXorSum(int* a int len)
{
int i 0
int temp 0
for( i < len i++)
{
temp temp ^ a[i]
}
return temp
}

int findFirstBit1(int n)
{
int count 1
while(( n & 1))
{
n n>>1
count++
}
return count
}

int isBit1(int a int count)
{
a a >> count1
return (a & 1)
}

void findTwoUnique(int* a int len)
{
int i 0
int m 0 n 0
int temp findXorSum(a len)
int count findFirstBit1(temp)
for( i < len i++)
{
if(isBit1(a[i]count))
{
m m ^ a[i]
}
else
{
n n ^ a[i]
}
}
printf(d d m n)
}

int main()
{
findTwoUnique(a8)
}
18 链表翻转出链表数k链表1→2→3→4→5→6k2翻转2→1→4→3→6→5k3翻转3→2→1→6→5→4k4翻转4→3→2→1→5→6程序实现
思想：采遍历链表分成lengthk组组进行逆转逆转时逆转尾头连接起
#include stdafxh
#include stdioh
#include stdlibh
#include

typedef struct Node{
int value
Node* next
}LinkList

void Converse(LinkList* pPreLinkList* pCur)
{ 链表逆转
LinkList* p NULL
LinkList* pNext NULL
p pPre>next
LinkList* p1 NULL
if(pCurNULL)
pNext pCur>next

while( ppNext)
{
p1 p>next
p>next pPre
pPre p
p p1
}
}

int main()
{
int count 0 ki0j0flag 1length0groups 0
scanf(d&k)
LinkList* pPre (LinkList*)malloc(sizeof(LinkList))
LinkList* pCur (LinkList*)malloc(sizeof(LinkList))
LinkList* pNext (LinkList*)malloc(sizeof(LinkList))
LinkList* head NULL
LinkList* pTempTail NULL 指逆转尾部
LinkList* pTempHead NULL

pCur>value 1
pPre pCur 创建初始链表
for(i2i<6i++) {
LinkList* node (LinkList*)malloc(sizeof(LinkList))
node>value i
pCur>next node
pCur node
}
pCur>next NULL定置NULLc++中new须置NULL

pCur pPre
while(pCurNULL)
{
length++
pCur pCur>next
}
i0
groups lengthk 分成K段
pCur pPre
while(i {
count 0
while(count {
pCur pCur>next
count++
}

if(i {
pNext pCur>next
pTempHead pCur *没做翻转前头部变成翻转尾部*
if(flag 0)
{
pTempTail>next pTempHead
}
pTempTail pPre
Converse(pPrepCur)
pTempTail pPre
if(flag1)
{
head pCur
flag 0
}
pCur pNext
}
else
{
pTempTail>next pNext
}
pPre pCur
i++
}


pCur head

while(j j++
printf(dpCur>value)
pCur pCur>next
}
printf(＼n)
system(pause)
return 0
}
19 链表相邻元素翻转a>b>c>d>e>fg翻转变：b>a>d>c>f>e>g
#include
#include
#include

typedef struct node{
char val
struct node* pNext
}Node

Node* CreateList(int n)
void Traverslist(Node* pHead)
Node* TransNeighbor(Node* pHead)

int main(){
Node* pHead CreateList(7)
printf(before transform＼n)
Traverslist(pHead)
TransNeighbor(pHead)
printf(＼nafter transform＼n)
Traverslist(pHead)
getchar()
return 1
}
创建新链表
Node* CreateList(int n){
Node* pHead (Node*)malloc(sizeof(Node))
Node* pTail pHead
pTail>pNextNULL
int i
for(i0 i < n i++){
Node* pNew (Node*)malloc(sizeof(Node))
pNew>val ＇a＇+i
pTail>pNext pNew
pNew>pNext NULL
pTail pNew

}
return pHead
}

void Traverslist(Node* pHead){
Node* p pHead>pNext
int isFirst 0
while(p NULL)
{
if(isFirst0)
{
printf(cp>val)
isFirst1
}else{
printf(>cp>val)
}
p p>pNext
}
return
}

Node* TransNeighbor(Node* pHead){
Node* p pHead>pNext
while(p>pNextNULL && p>pNext>pNextNULL)
{
char value p>val
p>valp>pNext>val
p>pNext>valvalue
pp>pNext>pNext
}
return pHead
}
20 输入串字符串中普通字符括号组成（包括（’）’[’＇]＇）求验证括号否匹配果匹配输出0否输出1
#include
#include
#define MAX 100
int main()
{
char a[100]c[](((1+2))
int i0j0
int flag0
while(c[i]NULL&&flag0)
{
switch(c[i])
{
case(＇(＇)
case(＇[＇)
a[j++]c[i]break
case(＇)＇)
if(a[j1]＇(＇)
{
a[j1]＇＼0＇
j
}
else
flag1
break
case(＇]＇)
if(a[j1]＇[＇)
{
a[j1]＇＼0＇
j
}
else
flag1
break

}
i++
}
if(j0) flag1
printf(d＼nflag)
return 0
}
方法2：#include
#include
#include 分配存头文件
#define m 20
typedef char ElemType
typedef struct
{
ElemType stack[m]
int top
}stacknode
stacknode *sp
Init(stacknode *st)
{
st>top0
return 0
}
void Push(stacknode *stElemType x)
{
if(st>topm)
printf(The stack is overflow＼n)
else
{
st>topst>top+1
st>stack[st>top]x
}
}
void Pop(stacknode *st)
{
st>topst>top1
}
main()
{
char s[m](()
int i
printf(Creat a stack＼n)
sp (stacknode *)malloc(sizeof(stacknode)) 添加语句
Init(sp)
printf(Input a expression＼n)
gets(s)
for(i0i {
if(s[i]＇(＇)
Push(sps[i])
if(s[i]＇)＇)
Pop(sp)
}
if(sp>top0)
printf(左右括号匹配＼n)
else
printf(左右括号匹配＼n)
return 0
}
２１．第行中含第二行中23数输出排序
2输入行数字：123 423 5645 875 186523
输入第二行：23
第行中含第二行中23数输出排序
结果：123 423 186523
#include
#define M 20

int main()
{
int a[M]
int ijstemp
int sort[M]t0
char c＇ ＇
i0
while(c＇＼n＇)
{
scanf(dc&temp&c)
a[i++]temp
}
scanf(d&s)
for(j0j {
tempa[j]
if(temp100s)
{
sort[t++]a[j]
}
else
temp10
}
for(i0i for(j0j {
if(sort[j]>sort[j+1])
{
tempsort[j+1]
sort[j+1]sort[j]
sort[j]temp
}
}
for(i0i printf(d sort[i])
printf(＼n)
return 0
}
２２输入m字符串 整数n 字符串M化成N单位段足位数0补齐
 n8 m9 
123456789划分：12345678
90000000
123化 ：12300000
#include
#include

int main()
{
char c[200]{＇＼0＇}
scanf(s&c)
int nij
int lenstrlen(c)
scanf(d&n)
for(i1i {
jin
printf(cc[i1])
if(j0)
printf(＼n)
}
if(j0)
for(ij+1i printf(0)
return 0
}
２３ 电话号码 one two nine zero
翻译成1  2 9 0
中间会double
例输入：OneTwoThree
输出：123
输入：OneTwoDoubleTwo
输出：1222
输入：1Two2 输出：ERROR
输入：DoubleDoubleTwo 输出：ERROR
空格非法字符两Double相连Double位单词 错误
#include
#include
#include
int main()
{
char a[11][11]{zeroonetwothreefourfivesixseveneightninedouble}
char temp[11] c＇ ＇
int ijfd0
while(c＇＼n＇)
{
scanf(sc&temp&c)
f0
for(j0j<11j++)
{
if(strcmp(tempa[j])&&j<10)
{
printf(dj)
f1
if(d1)
{
printf(dj)
d0
}
}
else if(strcmp(tempa[j])&&j10)
{
d1
f1
}
}
if(f0)
break
}
if(d1||f0)
printf(error＼n)
printf(＼n)
return 0
}
２４．整数倒序输出剔重复数
输入整数123365441750然位开始倒输出果0输出输出数字带重复数字面输出456321571果负数输入175输出571
#include
#include
#include
#include

int main()
{
char *input(char*)malloc(sizeof(char))
scanf(sinput)
int a[10]{0}iflag0flag10
int lenstrlen(input)
if(input[0]＇＇)
{
flag1
for(i0i input[i]input[i+1]
}
int len1strlen(input)
int n[50]temp
int count0
for(i0i {
tempinput[i]＇0＇
if(a[temp]0)
{
n[count++]temp
a[temp]1
}
}
n[count]＇＼0＇
if(flag1)
printf()

for(int iicount1ii>0ii)
{
if(n[ii]0||flag10)
{
printf(dn[ii])
flag11
}
}
printf(＼n)
return 0
}


２５．编程时候if条件里面()括号常出现匹配情况导致编译请编写程序检测输入行
if语句中圆括号否匹配正确时输出语句中出现左括号右括号数量if((a1)&&(b1))正确if((a1))&&(b1))错误注意if语句外面少括号提示：堆栈做
输入：if((a1)&&(b1))
输出：RIGTH 3 3
输入：if((a1))&&(b1))
输出：WRONG 3 4
#include
#include
int main()
{
char s[800]{＇＼0＇}
scanf(s&s)
char s[]if(())
int lenstrlen(s)
int ileft0right0
int a[50]k0flag1
for(i0i {
if(s[i]＇(＇)
{
left++
a[k]1
k++
}
else if(s[i]＇)＇)
{
right++
if(a[k1]1&&k>0)
{
a[k1]0
k
}
else
flag0
}
if((i2&&s[i]＇(＇)||(ilen1&&s[i]＇)＇))
flag0
}
if(a[0]0&&flag0)
printf(RIGHT)
else
printf(WRONG)
printf(d d＼nleftright)
return 0
}
约瑟夫问题
输入机数组成数列（数列中数均0整数长度已知）初始计数值m数列首位置开始计数计数m数列该位置数值换计数值m数列该位置数值出列然位置新开始计数直数列数值出列止果计数达数列尾段返回数列首位置继续计数请编程实现述计数程时输出数值出列序
：输入机数列：3124初始计数值m7数列首位置开始计数（数值3位置）
第轮计数出列数字2计数值更新m2出列数列314数值4位置新开始计数
第二轮计数出列数字3计数值更新m3出列数列14数值1位置开始计数
第三轮计数出列数字1计数值更新m1出列数列4数值4位置开始计数
轮计数出列数字4计数程完成
输出数值出列序：2314
求实现函数：
void array_iterate(int len int input_array[] int m int output_array[])
输入 int len：输入数列长度
int intput_array[]：输入初始数列
int m：初始计数值
输出 int output_array[]：输出数值出列序
返回
示例
输入：int input_array[] {3124}int len 4 m7
输出：output_array[] {2314}
解题思路：
次出列数值需minput_arrayoutput_array输出位置outPos起始位置startPos进行更新
输出位置outPos计算关键通分析知outPos(startPos+m1)num
代码实现：
view plaincopy to clipboardprint
#include
void print_array(int len int array[])
{
for(int i0 i printf(d array[i])
printf(＼n)
}
input_arraya[0]a[len1]
void array_iterate(int len int input_array[] int m int output_array[])
{
int startPos0
int outPos
int nIterlen1
int numlen
for( nIter>0 nIter)
{
outPos(m+startPos1)num
minput_array[outPos]
startPosoutPos
printf(outPos is d new m is d＼n outPos m)
output_array[lennIter1]input_array[outPos]
for(int ioutPos i input_array[i]input_array[i+1]
num
print_array(num input_array)
}
}
void main()
{
int input_array[]{3124}
int output_array[4]{0}
array_iterate(4 input_array 7 output_array)
print_array(4 output_array)
}
27统计数字出现次数次数统计出
举例：
输入：323324423343
输出：36

#include
#include
#include
int main()
{
char *num323324423343
int a[10]{0}
int lenstrlen(num)
int ijtempcount0maxnum0
printf(d＼nlen)

for(i0i {
tempnum[i]＇0＇
a[temp]++
}
int temp1a[0]
for(j0j<10j++)
{
if(a[j]0)
{
count++
temp1(temp1>a[j])temp1a[j]
printf(d d＼na[j]j)
}
}
printf(数字出现次数d＼ncount)
printf(次数d＼ntemp1)
return 0
}
28 字符串首字母转换成写
举例：
输入：this is a book
返回：This Is A Book

#include
#include
#include
int main()
{
char input[]this is a book
char output[256]{＇＼0＇}
int ilen
lenstrlen(input)
printf(变换前字符串s＼ninput)
for(i0i {
if(input[0]＇ ＇)
input[0]32
if(input[i]＇ ＇)
input[i+1]32
output[i]input[i]
}
printf(变换字符串s＼noutput)
}
29 子串分离 
题目描述：   
通键盘输入意字符串序列字符串包含子串子串空格分隔请编写
程序动分离出子串’’分隔补充’’子
串存储  
果输入abc def gh i        d结果abcdefghid 
求实现函数：   
void DivideString(const char *pInputStr long lInputLen char *pOutputStr) 
输入  pInputStr：  输入字符串 
         lInputLen：  输入字符串长度                   
输出  pOutputStr：  输出字符串空间已开辟输入字符串等长 
 
#include
#include
#include
#include
void DivideString(const char *pInputStr long lInputLen char *pOutputStr)
{

int cnt
const char *ppInputStr
while(*pNULL)
{
if(*p＇ ＇)
{ cnt 0
*pOutputStr++ *p++
}
else
{ cnt++
p++
if(cnt1)
*pOutputStr++ ＇＇

}
}
*pOutputStr++ ＇＇
*pOutputStr ＇＼0＇
}

void main()
{
char *str abc def gh i d
long len strlen(str)
char *outstr (char*)malloc(sizeof(str))
char outstr[100]
DivideString(strlenoutstr)
printf(soutstr)
printf(＼n)
}


9月份华面试没通知参加10月份华软件面试：
10月18号午西工投简历然通知22号机试利四天时间网年贴出华机试题进行整理道题重新整理编写遍网贴出答案代码变量考虑周全进行改正保证道题运行错误（机试题均含考题目算泄密哈…………）
23号通知面试：9点15准时面试点然面技术面面试官蔼首先介绍然找项目头尾讲遍务听懂项目期间遇问题解决方式项目中感受收获什差讲时（时面试算长吧）然说次面试没问软件方面东西LZ听出问题说科班出身时直编程通信方面书籍相信进入公司学力……时面试官接话说知道学力强然出等通知然等性格测试
纠结性格测试差做时建议做36分钟没准确时间限定时快吃午饭倒数第二批进测试确出……差10秒吧通知先吃午饭（华午餐错服务态度）
午二面（终面）终面传说中ＨＲ研发感觉研发部门理点网介绍骗……介绍介绍具体项目然问啥问题想问开始问：您会面试感觉样笑说问题面试期间方便回答面试相关问题重新问问网说华工作非常累非常忙真实情况（感觉问题非常棒＾＾勾起面试官美回忆扯差１５分钟）然引加班工作忙累法进入华愿景然回等通知欣喜２４号午收通知２５号签约早果断签
科普通二物理专业出身读研转目标识华直工作中佳选择９月份现１０月底四五ｏｆｆｅｒ拒直等华呵呵现愿认力出众软件公司勉强通笔试死面试特面阿里时候面试官重光老师（ｉ应该样写呵呵）针见血指出足非常中肯建议找工作中起非常帮助非常感谢写吧

文档香网(httpswwwxiangdangnet)户传

《香当网》用户分享的内容，不代表《香当网》观点或立场，请自行判断内容的真实性和可靠性！
该内容是文档的文本内容，更好的格式请下载文档