华为机考-模拟练习

• 1、字符串最后一个单词的长度
  题目描述
  计算字符串最后一个单词的长度，单词以空格隔开。
  输入描述:
  一行字符串，非空，长度小于5000。

  输出描述:
  整数N，最后一个单词的长度。

  示例1
  输入
  hello world
  输出
  5

  package main
  import "bufio"
  import "os"
  import "fmt"
  
  func main(){
      reader:=bufio.NewReader(os.Stdin)
      bytes,_,_:=reader.ReadLine()
      str:=string(bytes)
      a:=0
      for i:=0;i<len(str);i++{
          if str[i]==' '{
              a=i+1
          }
      }
      fmt.Println(len(str)-a)
  }
  

• 2、计算字符个数
  题目描述
  写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。

  输入描述:
  输入一个有字母和数字以及空格组成的字符串，和一个字符。

  输出描述:
  输出输入字符串中含有该字符的个数。

  示例1
  输入
  ABCDEF A
  输出
  1

  package main
  import "fmt"
  func main(){
      a,b:="",""
      fmt.Scanf("%s\n%s\n",&a,&b)
      count:=0
      for i:=0;i<len(a);i++{
          a1:=string(a[i])//这个主意，string[i]其类型是byte
          a2:=string(a[i]+'A'-'a')
          a3:=string(a[i]-'A'+'a')
          if a1==b||a2==b||a3==b{
              count++
          }
      }
      fmt.Println(count)
  }
  

• 3、明明的随机数

  题目描述
  明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

  Input Param

  n 输入随机数的个数

  inputArray n个随机整数组成的数组

  Return Value

  OutputArray 输出处理后的随机整数

  注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

  输入描述:
  输入多行，先输入随机整数的个数，再输入相应个数的整数

  输出描述:
  返回多行，处理后的结果

  示例1
  输入
  11
  10
  20
  40
  32
  67
  40
  20
  89
  300
  400
  15
  输出
  10
  15
  20
  32
  40
  67
  89
  300
  400
  吐槽：就不能多次调用程序，一次检查case吗，非得一个程序多个case吗，到底是考写程序的能力，还是考察oj呢！非人类，牛客oj向leetcode学下可以么

  package main
  import "fmt"
  var flag=make([]int,1010)//用空间换时间，简单方便
  func main(){
  	n,tmp,max:=0,0,0
  	for{
  		a,b:=fmt.Scanln(&n)
  		if a==0||b!=nil{  //oj上一定处理输入的返回值
  			break
  		}
  		for i:=0;i<n;i++{
  			_,_=fmt.Scanln(&tmp)
  			flag[tmp]=1
  			if tmp>=max{
  				max=tmp
  			}
  		}
  		for i:=0;i<=max;i++{
  			if flag[i]==1{
  				fmt.Println(i)
  				flag[i]=0
  			}
  		}
  	}
  }
  

• 4、0交换排序

  长度为n的数组乱序存放着0至n-1. 现在只能进行0与其他数的交换，完成以下函数

  /**
   * 交换数组里n和0的位置
   * array: 存储[0-n)的数组
   * len: 数组长度
   * n: 数组里要和0交换的数
   */
  extern void swap_with_zero(int* array, int len, int n);
  
  class Solution {
  public:
      /**
     * 调用方法swap_with_zero来对array进行排序
    */
  
    void sort(int* array, int len) {
  	    swap_with_zero(array,len,array[0]);
   	   for(int i=1;i

• 5、汽水瓶
  有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

  输入描述:
  输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

  输出描述:
  对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

  示例1
  输入
  3
  10
  81
  0
  输出
  1
  5
  40

• 6、删数
  有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。

  输入描述:
  每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。

  输出描述:
  一行输出最后一个被删掉的数的原始下标位置。

  输入例子1:
  8

  输出例子1:
  6

  package main
  import "fmt"
  func delNum(n int)int{
  	flag:=make([]int,n)
  	done,two,last:=n,0,0
  	for done>0{
  		for i:=0;i<n;i++{
  			if flag[i]==0{//在未删除的数上进行
  				if two==2{//删除
  					flag[i]=1
  					done--
  					last=i
  					two=0
  				}else {//计数
  					two++
  				}
  			}
  		}
  	}
  	return last
  }
  func main(){
  	num:=0
  	for {
  		n,err:=fmt.Scanln(&num)
  		if n==0||err!=nil{
  			break
  		}
  		if num>1000{
  			num=999
  		}
  		fmt.Println(delNum(num))
  	}
  }
  
  

• 字符集合
  输入一个字符串，求出该字符串包含的字符集合

  输入描述:
  每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。

  输出描述:
  每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。

  输入例子1:
  abcqweracb

  输出例子1:
  abcqwer

  package main
  import "fmt"
  var a=make([]int,26)
  var A=make([]int,26)
  func main(){
  	s:=""
  	for {
  		n,err:=fmt.Scanf("%s",&s)
  		if n==0||err!=nil{
  			break
  		}
  		for _,b:=range s{
  			if b-'a'>=0&&b-'z'<=0{
  				if a[b-'a']==0{//作可以输出标记
  					fmt.Printf(string(b))
  				}
  				a[b-'a']=1
  			}
  			if b-'A'>=0&&b-'Z'<=0{
  				if A[b-'A']==0{
  					fmt.Printf(string(b))
  				}
  				A[b-'A']=1
  			}
  		}
  		for i,_:=range a{
  			a[i]=0
  		}
  		for i,_:=range A{
  			A[i]=0
  		}
  		fmt.Println()
  	}
  }
  

  //普通解决方法，但也因为输入处理问题0case通过，恶心啊
  package main
  import "fmt"
  var count =make([]int,110)
  func main(){
  	n:=0
  	_,_=fmt.Scanln(&n)			
  	for n>0{
  		a:=0
  		for n>2{
  			a+=n/3；n=n%3+n/3
  			if n==2{
  				n++
  			}
  		}
  		fmt.Println(a)
  		b,err:=fmt.Scanln(&n)
  		//一定处理输入的返回值，尽管说明了n==0,结束
  		//但并没什么鸟用，谁知道牛客网怎么处理的，怎么会出现这种情况！
  		if b==0||err!=nil{
  			break
  		}
  	}
  }
  

  //观察法!
  package main
  import "fmt"
  func main() {
  	n := 0
  	_, _ = fmt.Scanln(&n)
  	for n != 0 {
  		fmt.Println(n / 2)//从输入输出可得到规律，结果是输入/2
  		a,b:= fmt.Scanln(&n)
  		if a==0||b!=nil{
  			break
  		}
  	}
  }
  

• 进制转化
  写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

  package main
  import "fmt"
  func main(){
  	a:=0
  	for{
  		n,err:=fmt.Scanf("0x%x",&a)
  		//直接用Scanf的格式化输入解决的
  		//本以为会是多个呢，如0xa0xb0xc然后转化成10进制结果呢
  		//结果就转化个单位数
  		if n==0||err!=nil{
  			break
  		}
  		fmt.Println(a)
  	}
  }
  

package main

import "fmt"

/*
1.构造二维
2.查看横竖数字，确定唯一的
3.
*/
var xy [9][9]int
func who(i,j int)int{
	var mp =make(map[int]int)
	for a:=0;a<9;a++{
		if xy[a][j]!=0{
			mp[xy[a][j]]=1
			//fmt.Printf("%d ",xy[a][j])
		}
	}
	for b:=0;b<9;b++{
		if xy[i][b]!=0{
			mp[xy[i][b]]=1
			//fmt.Printf("%d ",xy[i][b])
		}
	}
	//blcok
	for a:=i-i%3;a<i-i%3+3;a++{
		for b:=j-j%3;b<j-j%3+3;b++{
			if xy[a][b]!=0{
				mp[xy[a][b]]=1
				//fmt.Printf("%d ",xy[a][b])
			}
		}
	}
	count:=0
	b:=0

	//fmt.Println()
	for a:=1;a<=9;a++{
		if _,ok:=mp[a];!ok{
			b=a;count++
			//fmt.Printf("%d ",a)
		}
	}
	//fmt.Println()
	if count==1{
		return b
	}else{
		return -1
	}
}
type point struct{
	x,y int
}
var que =make(map[point]int)
func main(){
	tmp:=0
	for i:=0;i<9;i++{
		for j:=0;j<9;j++{
			n,err:=fmt.Scanf("%d",&tmp)
			if n==0||err!=nil{
				break
			}
			xy[i][j]=tmp
			if tmp==0{
				que[point{i,j}]=1
			}
		}
	}

	for len(que)>0{
		for a,_:=range que{
			c:=who(a.x,a.y)
			if c>0{
				xy[a.x][a.y]=c
				delete(que,a)
				//show()
			}
		}
		//show()
	}
	for i:=0;i<9;i++{
		for j:=0;j<9;j++{
			if j==8{
				fmt.Println(xy[i][j])
			}else{
				fmt.Printf("%d ",xy[i][j])
			}
		}
	}

}
func show(){
		for i:=0;i<9;i++{
		for j:=0;j<9;j++{
			if j==8{
				fmt.Println(xy[i][j])
			}else{
				fmt.Printf("%d ",xy[i][j])
			}
		}
	}

}

/*
用例:
0 9 5 0 2 0 0 6 0
0 0 7 1 0 3 9 0 2
6 0 0 0 0 5 3 0 4
0 4 0 0 1 0 6 0 7
5 0 0 2 0 7 0 0 9
7 0 3 0 9 0 0 2 0
0 0 9 8 0 0 0 0 6
8 0 6 3 0 2 1 0 5
0 5 0 0 7 0 2 8 3

对应输出应该为:

3 9 5 7 2 4 8 6 1
4 8 7 1 6 3 9 5 2
6 2 1 9 8 5 3 7 4
9 4 2 5 1 8 6 3 7
5 6 8 2 3 7 4 1 9
7 1 3 4 9 6 5 2 8
2 3 9 8 5 1 7 4 6
8 7 6 3 4 2 1 9 5
1 5 4 6 7 9 2 8 3
*/

• 最高分是多少
  老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.

  输入描述:
  输入包括多组测试数据。
  每组输入第一行是两个正整数N和M（0 < N <= 30000,0 < M < 5000）,分别代表学生的数目和操作的数目。
  学生ID编号从1编到N。
  第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩
  接下来又M行，每一行有一个字符C（只取‘Q’或‘U’），和两个正整数A,B,当C为’Q’的时候, 表示这是一条询问操作，他询问ID从A到B（包括A,B）的学生当中，成绩最高的是多少
  当C为‘U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

  输出描述:
  对于每一次询问操作，在一行里面输出最高成绩.

  输入例子1:
  5 7
  1 2 3 4 5
  Q 1 5
  U 3 6
  Q 3 4
  Q 4 5
  U 4 5
  U 2 9
  Q 1 5

  输出例子1:
  5
  6
  5
  9

package main  //还以为会考特殊搜索算法呢，结果就是模拟题
import "fmt"
var S []int
func query(a,b int)int{
	if a>b{
		t:=a;a=b;b=t//没注意，还会给，9,5这种反着的范围
	}
	max:=S[a]
	for i:=a;i<=b&&i<len(S);i++{
		if S[i]>max{
			max=S[i]
		}
	}
	return max
}
func set(i,s int){
	S[i]=s
}
func main(){
	N,M:=0,0
	for {
		n,err:=fmt.Scanf("%d %d\n",&N,&M) //恶心牛客网的输入
		if n==0||err!=nil{
			break
		}
		S=make([]int,N)
		a,b,c:="",0,0
		for i:=0;i<N;i++{
			n,err:=fmt.Scanf("%d",&b)
			if n==0||err!=nil{
				break
			}
			set(i,b)
		}
		for i:=0;i<M;i++{
			n,err:=fmt.Scanf("%s %d %d\n",&a,&b,&c)
			if n==0||err!=nil{
				fmt.Println(n,err)
				break
			}
			switch a[0] {
			case 'Q':
				fmt.Println(query(b-1,c-1))
			case 'U':
				set(b-1,c)
			}
		}
	}
}