携程2019秋招专业笔试

1、查询满足区间的记录

有一批订单记录，数据有订单号，入店时间，离店时间；
输入一个时间值A，需要在这批记录中找到符合入离店时间范围（A大于等于入店时间，并且A小于等于离店时间）
内的所有记录。 单次查询时间复杂度控制在O(logN)
※注意：订单号升序输出

输入描述:
记录数：10
时间值A：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

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
class Order implements Comparable<Order>{
	int id;
	int inTime;
	int outTime;
	public Order(int id,int inTime,int outTime) {
		// TODO Auto-generated constructor stub
		this.id = id;
		this.inTime = inTime;
		this.outTime = outTime;
	}
	@Override
	public int compareTo(Order order) {
		return this.id - order.id;
	}						
}
public class Main {			
	public static void main(String[] args) {		
		Scanner sc = new Scanner(System.in);
		int records = sc.nextInt();
		int time = sc.nextInt();
		ArrayList<Order> orderList = new ArrayList<Order>();
		for(int i = 0;i < records;i++) {
			int id = sc.nextInt();
			int inTime = sc.nextInt();
			int outTime = sc.nextInt();
			Order order = new Order(id, inTime, outTime);
			orderList.add(order);		
		}
		Collections.sort(orderList,new Comparator<Order>() {
			@Override
			public int compare(Order o1, Order o2) {
				// TODO Auto-generated method stub
				if(o1.inTime == o2.inTime) {
					if(o1.outTime == o2.outTime)
						return o1.id - o2.id;
					return o2.outTime - o1.outTime;
				}					
				return o1.inTime - o2.inTime;
			}
		});		
		int index = binarySearch(orderList,time);
		ArrayList<Integer> res = new ArrayList<Integer>(); 
		for(int i = 0;i < index;i++) {
			Order order = orderList.get(i);
			if(time >= order.inTime && time <= order.outTime) {
				res.add(order.id);
			}
		}	
        Collections.sort(res);
		if(res.size() == 0)
			System.out.println("null");
		for(Integer integer : res) {
			System.out.println(integer);
		}			
	}
	public static int binarySearch(ArrayList<Order> list,int time) {
		int left = 0,right = list.size();
		while (left < right) {
			int mid = (left + right)/2;
			if(list.get(mid).inTime <= time)
				left = mid + 1;
			else 
				right = mid;			
		}
		return left;
	}
}

2.bit count

输入一个long类型的数值, 求该数值的二进制表示中的1的个数 .、

输入
65
输出
2
说明
65的二进制为:1000001，所以１的个数为：2

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        long num = sc.nextLong();
        System.out.println(NumberOf1(num));
    }
    public static int NumberOf1(long n) {
        int count = 0;
        long flag = 1;
        while (flag != 0) {
            if ((flag & n) != 0)
                count++;
            flag = flag << 1;
        }
        return count;
    }
}