情景题笔试记录

1.携程(9/5)

思路：

class Node{
	int dingdan;
	int ruzhu;
	int lidian;
	
}
class TestJava{
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		ArrayList<Integer> list = new ArrayList<>();
		while(in.hasNext()){
			int count = in.nextInt();
			int time = in.nextInt();
			Node[] node = new Node[count];
			for(int k=0;k<node.length;k++){
				node[k] = new Node();
			}
			for(int k=0;k<count;k++){
				node[k].dingdan = in.nextInt();
				node[k].ruzhu = in.nextInt();
				node[k].lidian = in.nextInt();
				if(time>=node[k].ruzhu&&time<=node[k].lidian)
					list.add(node[k].dingdan);
			}
			if(list.size()==0){
				System.out.println("null");
			}
			Collections.sort(list);
			for(int i:list){
				System.out.println(i);
			}
		}
	}
}

测试用例：

测试用例一：
 10
20180602
1001 20180103 20180105
1002 20180202 20180203
1003 20180304 20180306
1004 20180401 20180408
1005 20180501 20180504
1006 20180601 20180604
1007 20180705 20180706
1008 20180801 20180804
1009 20180903 20180903
1010 20181003 20181003
输出： 
1006
测试用例二：
4
20180103
1013 20180103 20180105
1022 20180102 20180103
1026 20180103 20180103
1007 20180101 20180109
输出
1007
1013
1022
1026
测试用例三：
5
20170103
1013 20180103 20180105
1022 20180102 20180103
1103 20180104 20180106
1034 20180101 20180102
1105 20180201 20180204

输出：
null

？？查询的时间复杂度是O(logn)怎么理解

2.Long类型数字中的1的个数（剑指offer上的原题，剑指offer上是整型int,这里是long）

3.

 

2.华为情景题：

第一题：

这题是典型的DFS，代码演示：

class TestJava{
	public static void main(String[] args) {
		int [][] a =  {{1,1,1,1,1,1,1,1,1,1},
			    {1,1,1,0,0,0,0,0,0,0},
	            {1,0,1,0,1,1,1,1,1,0},
			    {0,1,0,0,1,0,0,0,0,0},
			    {0,0,0,0,1,1,1,1,1,1},//有A
			    {0,0,0,0,1,0,1,1,1,1},
			    {0,0,0,0,1,0,1,1,1,1},
			    {0,1,1,1,1,1,1,1,1,1},
			    {0,1,1,1,1,1,1,1,1,1},
			    {0,1,1,1,1,1,1,1,1,1}};
		int x = 3;
		int y = 3;
		int hang = a.length;
		int lie = a[0].length;
		int [][] flag = new int[hang][lie];
		System.out.println(Helper(a,x,y,flag));;
	}
	public static boolean Helper(int[][] a,int i,int j,int[][] flag){
		if(i<0||j<0||i>a.length||j>a[0].length)
			return false;
		if(i==0||j==0||i==a.length||j==a[0].length){
//			System.out.println("i: "+i+"j: "+j);
			return true;
		}	
		if(a[i][j]==0&&flag[i][j]==0){
			flag[i][j] = 1;
			boolean right = Helper(a,i+1,j,flag);
			boolean left = Helper(a,i-1,j,flag);
			boolean up = Helper(a,i,j+1,flag);
			boolean down = Helper(a,i,j-1,flag);
			flag[i][j] = 0;
			return right||left||up||down;
		}
		return false;
	}
}

第二题：

第三题：

京东的题

class Good{
	int x,y,z,index;
	public Good(int x, int y, int z, int index){
		this.x = x;
		this.y = y;
		this.z = z;
		this.index = index;
	}
}

public class TestJava {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		if(n <= 0){
			System.out.println(0);
			return;
		}
		ArrayList<Good> li = new ArrayList<Good>();
		for(int i=0; i<n; i++){
			li.add(new Good(sc.nextInt(), sc.nextInt(), sc.nextInt(), i+1));
		}
		
		int count = 0;
		int flag = 0;
		for(int i=0; i<n; i++){
			Good g1 = li.get(i);
			flag = 0;
			for(int j=0; j<n; j++){
				Good g2 = li.get(j);
				if(g2.x>g1.x && g2.y>g1.y && g2.z>g1.z){
					flag = 1;
					break;
				}
			}
			if(flag == 1){
				count++;
			}
		}
		System.out.println(count);
	}
}

头条的题——孤岛问题

/*
4
1 0 0 0
0 0 0 0
0 0 0 1
0 0 0 0 
*/

//孤岛问题
public class TestJava {  
	private static int[][] array ;

public static void main(String[] args) { 
	Scanner in = new Scanner(System.in);
	int isFirst = 1;
	while(in.hasNext()){
		int count = in.nextInt();
		array = new int[count][count];
		for(int i=0;i<count;i++){
			for(int j=0;j<count;j++){
				array[i][j] = in.nextInt();
			}
		}
//		int count = Integer.valueOf(in.nextLine());
//		for(int i=0;i<count;i++){
//			String str = in.nextLine();
//			String[] a = str.split("\\s");
//			if(isFirst==1){
//				isFirst=0;
//				array = new int[count][a.length];
//			}
//			for(int j=0;j<a.length;j++){
//				array[i][j] = Integer.valueOf(a[j]);
//			}
//		}
		int maxLine = array.length;	//列
		int maxRow = array[0].length;		//行
		int[][] flag = new int[maxRow][maxLine];
		int countNum = 0;
		for(int i=0;i<maxRow;i++){
			for(int j=0;j<maxLine;j++){
				if(array[i][j]==1&&flag[i][j]==0){
					helper(i,j,maxRow,maxLine,flag);
					countNum++;
					
				}
			}
		}
		System.out.println(countNum);
	}
	
}  

public static void helper(int i,int j,int maxRow,int maxLine,int[][] flag){
	//如果没有找到就继续
	if(i<0||j<0||i>=maxRow||j>=maxLine)
		return;
	if(array[i][j]==1&&flag[i][j]==0){
		flag[i][j] = 1;	//已经走过的路径设置为5
		helper(i-1,j,maxRow,maxLine,flag);
		helper(i+1,j,maxRow,maxLine,flag);
		helper(i,j+1,maxRow,maxLine,flag);
		helper(i,j-1,maxRow,maxLine,flag);
		//flag[i][j] = 0;	//这行不需要
	}
	
  }
}

中兴的题——Map的value值排序

import java.util.*;
public class Solution{
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		while(scan.hasNext()) {
			LinkedHashMap<Integer,Integer> map=new LinkedHashMap();
			int num=scan.nextInt();
			for(int i=0;i<num;i++) {
				int salary=scan.nextInt();
				if(map.containsKey(salary)) {
					int value=map.get(salary)+1;
					map.put(salary,value);
				}
				else {
					map.put(salary,1);
				}
			}
			ArrayList<Map.Entry<Integer,Integer>> list = new ArrayList<>(map.entrySet());
			Collections.sort(list,new Comparator<Map.Entry<Integer,Integer>>() {
				public int compare(Map.Entry<Integer,Integer> entry1,Map.Entry<Integer,Integer> entry2) {
						return entry2.getValue()-entry1.getValue();
				}
			});
			System.out.println(list.size());
			for(Map.Entry<Integer,Integer> entry:list) {
				int salary=entry.getValue();
				for(int i=0;i<salary;i++)
					System.out.print(entry.getKey()+" ");
			}
		}
	}
}

情景题：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;


class myComparator implements Comparator<Integer>{
     @Override
     public int compare(Integer o1, Integer o2) {
            return o2-o1;
 }
public class Main {

	}

/*请完成下面这个函数，实现题目要求的功能
当然，你也可以不按照下面这个模板来作答，完全按照自己的想法来 ^-^ 
******************************开始写代码******************************/
    static int[] minLengthAvailable(String testcase) {
		String[] str = testcase.split("\\s");
		int n = Integer.valueOf(str[0]);
		int m = Integer.valueOf(str[1]);
		int k = Integer.valueOf(str[2]);
		ArrayList<Integer> list = new ArrayList<>();
		if(n>k){
			for(int i=0;i<n/k;i++){
				list.add(k);
			}
			n = n%k;
		}else{
			list.add(n%k);
		}
		int [] a = null;
		if(list.size()!=n){
			a = new int[list.size()];
			Collections.sort(list,new myComparator());
			for(int i=0;i<list.size();i++){
				a[i] = list.get(i);
			}
		}
		return a;
    }
/******************************结束写代码******************************/


    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int[] res;
            
        String _testcase;
        try {
            _testcase = in.nextLine();
        } catch (Exception e) {
            _testcase = null;
        }
  
        res = minLengthAvailable(_testcase);
        for(int res_i=0; res_i < res.length; res_i++) {
            System.out.println(String.valueOf(res[res_i]));
        }

    }
}

搜狐情景题

任意交换字符串的两个字符后，字符串依然相同，此时返回1，否则返回0

public class TestJava {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);
		String str1 = scan.next();
		String str2 = scan.next();
		char[] ch1 = str1.toCharArray();
		char[] ch2 = str2.toCharArray();
		if(str1.length()!=str2.length()){
			System.out.println(0);
		}else{
			int count = 0;
			ArrayList<Integer> arr = new ArrayList<Integer>();
			
			int i = 0;
			for(i = 0;i<str1.length();i++){
				if(ch1[i]!=ch2[i]){
					count++;
					arr.add(i);
				}
			}
			if(i==str1.length()&&count==0){
				HashMap<Character,Integer> map = new HashMap<>();
				for(int j=0;j<ch1.length;j++){
					if(map.containsKey(ch1[j])){
						System.out.println(1);
						return;
					}else{
						map.put(ch1[j], 1);
					}
				}
				System.out.println(0);
				return;
			}
				
			
			char s1 = ch1[arr.get(0)];
			char s2 = ch2[arr.get(1)];
			char s3 = ch1[arr.get(1)];
			char s4 = ch2[arr.get(0)];
			
			if(count>2){
				System.out.println(0);
			}else if(s1==s2&&s3==s4){
				System.out.println(1);
			}
		}
	}
}

小米(9/27)

暴力写法

class TestJava{
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		
		while(in.hasNext()){
			int n = Integer.valueOf(in.nextLine());		//使用in.nextInt()就不行
//			int n = in.nextInt();
			String[][] temp = new String[n][];
			for(int i=0;i<n;i++){
				String str = in.nextLine();
				String[] a = str.split("\\s");
				temp[i] = new String[a.length];
				
				for(int j=0;j<a.length;j++){
					temp[i][j] = a[j];
				}
			}
			
			ArrayList<String>[] list = new ArrayList[temp.length];
			for(int i=0;i<list.length;i++){
				list[i] = new ArrayList<>();	//这边记得初始化
			}
			
			for(int i=0;i<temp.length;i++){
				for(int j=0;j<temp[i].length;j++){
					list[i].add(temp[i][j]);
				}
			}
			
			int flag = 1;
			for(int i=0;i<list.length;i++){
				flag = 1;
				for(int j=i+1;j<list.length;j++){
					if(jiaoji(list[i],list[j])==true){
						list[i].addAll(list[j]);
						list[j] = null;
					}
				}
			}
			
			int count = 0;		//记录个数
			int max = Integer.MIN_VALUE;		//记录最大的集合
			for(int i=0;i<list.length;i++){
				if(list[i]!=null){
					count++;
					
					HashSet<String> set =  new HashSet<>(list[i]);
					if(set.size()>max)
						max = set.size();
				}
				
			}
			
			System.out.println("还剩下集合数目: "+count);
			System.out.println("剩下的集合的最大个数："+max);
		}
	}
	public static boolean jiaoji(ArrayList<String> l1,ArrayList<String> l2){
		if(l1== null||l2==null)
			return false;
		for(int i=0;i<l2.size();i++){
			if(l1.contains(l2.get(i)))
				return true;
		}
		return false;
	}
}