首页 > 试题广场 >

2021年国庆在北京接单3次及以上的司机统计信息

[编程题]2021年国庆在北京接单3次及以上的司机统计信息

热度指数：83109 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 256M，其他语言512M
算法知识视频讲解

用户打车记录表tb_get_car_record

（uid-用户ID, city-城市, event_time-打车时间, end_time-打车结束时间, order_id-订单号）

打车订单表tb_get_car_order

（order_id-订单号, uid-用户ID, driver_id-司机ID, order_time-接单时间, start_time-开始计费的上车时间, finish_time-订单完成时间, mileage-行驶里程数, fare-费用, grade-评分）

场景逻辑说明：

用户提交打车请求后，在用户打车记录表生成一条打车记录，order_id-订单号设为null；
当有司机接单时，在打车订单表生成一条订单，填充order_time-接单时间及其左边的字段，start_time-开始计费的上车时间及其右边的字段全部为null，并把order_id-订单号和order_time-接单时间（end_time-打车结束时间）写入打车记录表；若一直无司机接单，超时或中途用户主动取消打车，则记录end_time-打车结束时间。
若乘客上车前，乘客或司机点击取消订单，会将打车订单表对应订单的finish_time-订单完成时间填充为取消时间，其余字段设为null。
当司机接上乘客时，填充订单表中该start_time-开始计费的上车时间。
当订单完成时填充订单完成时间、里程数、费用；评分设为null，在用户给司机打1~5星评价后填充。

问题：请统计2021年国庆7天期间在北京市接单至少3次的司机的平均接单数和平均兼职收入（暂不考虑平台佣金，直接计算完成的订单费用总额），结果保留3位小数。

输出示例：

示例数据的输出结果如下

解释：

在2021年国庆期间北京市的订单中，202共接了3单，兼职收入105；203接了4单，兼职收入137；201共接了1单，但取消了；接单至少3次的司机有202和203，他两人全部总共接单数为7，总收入为242。因此平均接单数为3.500，平均收入为121.000；

示例1

输入

DROP TABLE IF EXISTS tb_get_car_record,tb_get_car_order;
CREATE TABLE tb_get_car_record (
    id INT PRIMARY KEY AUTO_INCREMENT COMMENT '自增ID',
    uid INT NOT NULL COMMENT '用户ID',
    city VARCHAR(10) NOT NULL COMMENT '城市',
    event_time datetime COMMENT '打车时间',
    end_time datetime COMMENT '打车结束时间',
    order_id INT COMMENT '订单号'
) CHARACTER SET utf8 COLLATE utf8_bin;

CREATE TABLE tb_get_car_order (
    id INT PRIMARY KEY AUTO_INCREMENT COMMENT '自增ID',
    order_id INT NOT NULL COMMENT '订单号',
    uid INT NOT NULL COMMENT '用户ID',
    driver_id INT NOT NULL COMMENT '司机ID',
    order_time datetime COMMENT '接单时间',
    start_time datetime COMMENT '开始计费的上车时间',
    finish_time datetime COMMENT '订单结束时间',
    mileage DOUBLE COMMENT '行驶里程数',
    fare DOUBLE COMMENT '费用',
    grade TINYINT COMMENT '评分'
) CHARACTER SET utf8 COLLATE utf8_bin;

INSERT INTO tb_get_car_record(uid, city, event_time, end_time, order_id) VALUES
 (101, '北京', '2021-10-01 07:00:00', '2021-10-01 07:02:00', null),
 (102, '北京', '2021-10-01 09:00:30', '2021-10-01 09:01:00', 9001),
 (101, '北京', '2021-10-01 08:28:10', '2021-10-01 08:30:00', 9002),
 (103, '北京', '2021-10-02 07:59:00', '2021-10-02 08:01:00', 9003),
 (104, '北京', '2021-10-03 07:59:20', '2021-10-03 08:01:00', 9004),
 (105, '北京', '2021-10-01 08:00:00', '2021-10-01 08:02:10', 9005),
 (106, '北京', '2021-10-01 17:58:00', '2021-10-01 18:01:00', 9006),
 (107, '北京', '2021-10-02 11:00:00', '2021-10-02 11:01:00', 9007),
 (108, '北京', '2021-10-02 21:00:00', '2021-10-02 21:01:00', 9008) ;

INSERT INTO tb_get_car_order(order_id, uid, driver_id, order_time, start_time, finish_time, mileage, fare, grade) VALUES
 (9002, 101, 201, '2021-10-01 08:30:00', null, '2021-10-01 08:31:00', null, null, null),
 (9001, 102, 202, '2021-10-01 09:01:00', '2021-10-01 09:06:00', '2021-10-01 09:31:00', 10.0, 41.5, 5),
 (9003, 103, 202, '2021-10-02 08:01:00', '2021-10-02 08:15:00', '2021-10-02 08:31:00', 11.0, 41.5, 4),
 (9004, 104, 202, '2021-10-03 08:01:00', '2021-10-03 08:13:00', '2021-10-03 08:31:00', 7.5, 22, 4),
 (9005, 105, 203, '2021-10-01 08:02:10', '2021-10-01 08:18:00', '2021-10-01 08:31:00', 15.0, 44, 5),
 (9006, 106, 203, '2021-10-01 18:01:00', '2021-10-01 18:09:00', '2021-10-01 18:31:00', 8.0, 25, 5),
 (9007, 107, 203, '2021-10-02 11:01:00', '2021-10-02 11:07:00', '2021-10-02 11:31:00', 9.9, 30, 5),
 (9008, 108, 203, '2021-10-02 21:01:00', '2021-10-02 21:10:00', '2021-10-02 21:31:00', 13.2, 38, 4);

输出

北京|3.500|121.000

算法知识视频讲解

海盗狗

我们PM要是给我这种一会儿左边全null一会儿右边全填充的这种NC描述早就被我追着打了

发表于 2022-01-07 15:47:30 回复(3)

Mysql

SandyFlyHigh

基础的数据需求，理解题目比写代码难 … 写代码时最易犯的错误就是把问题想的复杂了。

温馨提示：取消的订单也算订单，一个司机接单可能超过3单，但是3单都是取消的。

SELECT
    city,
    ROUND(AVG(order_cnt), 3) AS avg_order_num,
    ROUND(SUM(income_amount) / COUNT(driver_id), 3) AS avg_income
FROM
(SELECT
    city,
    driver_id,
    COUNT(t1.order_id) AS order_cnt,
    SUM(fare) AS income_amount
FROM tb_get_car_order AS t1
JOIN tb_get_car_record AS t2
ON t1.order_id = t2.order_id
WHERE
    DATE(order_time) BETWEEN '2021-10-01' AND '2021-10-07'
    AND
    city = '北京'
GROUP BY city, driver_id
HAVING order_cnt >= 3) AS t3
GROUP BY city;

发表于 2021-12-19 00:59:23 回复(9)

Mysql

牛客226360481号

SELECT city, round(avg(cnt), 3) as avg_order_num,
    round(avg(sum_fare), 3) as avg_income
FROM (
    SELECT city, driver_id, count(t1.order_id) as cnt,
        sum(fare) as sum_fare
    FROM tb_get_car_order as t1 JOIN tb_get_car_record as t2
    ON t1.order_id = t2.order_id
    WHERE date(order_time) between '2021-10-01' and '2021-10-07'
    AND city = '北京'
    GROUP BY city, driver_id
    HAVING cnt >= 3
) as t
GROUP BY city

发表于 2022-01-11 16:14:01 回复(1)

Mysql

酸菜鱼土豆大侠

【场景】：在某个数据的基础上再计算

【分类】：in子查询、where (a,b) in、group by having

分析思路

注意：

1.外键是order_id，不能用uid做连接
2.取消了订单也算接单，不要把问题想的太复杂

关键是理解业务

首先，搞清楚5个时间的业务关系

event_time-打车时间, end_time-打车结束时间, order_time-接单时间, start_time-开始计费的上车时间, finish_time-订单完成时间

（1）统计2021年国庆7天期间在北京市接单至少3次的司机

[条件]：date(order_time) between '20211001' and '20211007' and city = '北京'
[使用]：group by driver_id having count(order_time) >= 3

（2）统计2021年国庆7天期间在北京市接单至少3次的司机的平均接单数和平均兼职收入，结果保留3位小数

[使用]：sum() ;count()

求解代码

方法一

with子句

with
    main as(
        #统计2021年国庆7天期间在北京市接单至少3次的司机
        select
            driver_id,
            sum(fare) as fare_sum,
            count(order_time) as order_num
        from tb_get_car_order
        join tb_get_car_record using(order_id )
        where date(order_time) between '20211001' and '20211007'
        and city = '北京'
        group by driver_id having count(order_time) >= 3
    )
#统计2021年国庆7天期间在北京市接单至少3次的司机的平均接单数和平均兼职收入（暂不考虑平台佣金，直接计算完成的订单费用总额），结果保留3位小数。
select
    '北京' as city,
    round(sum(order_num)/count(distinct driver_id),3) as avg_order_num,
    round(sum(fare_sum)/count(distinct driver_id),3) as avg_income
from main

方法二

多表连接

#统计2021年国庆7天期间在北京市接单至少3次的司机的平均接单数和平均兼职收入（暂不考虑平台佣金，直接计算完成的订单费用总额），结果保留3位小数。
select
    '北京' as city,
    round(sum(order_num)/count(distinct driver_id),3) as avg_order_num,
    round(sum(fare_sum)/count(distinct driver_id),3) as avg_income
from(
    #统计2021年国庆7天期间在北京市接单至少3次的司机
    select
        driver_id,
        sum(fare) as fare_sum,
        count(order_time) as order_num
    from tb_get_car_order
    join tb_get_car_record using(order_id )
    where date(order_time) between '20211001' and '20211007'
    and city = '北京'
    group by driver_id having count(order_time) >= 3
) main

方法三

in子查询

#统计2021年国庆7天期间在北京市接单至少3次的司机的平均接单数和平均兼职收入（暂不考虑平台佣金，直接计算完成的订单费用总额），结果保留3位小数。
select
    city,
    round(count(order_id)/count(distinct driver_id),3) as avg_order_num,
    round(sum(fare)/count(distinct driver_id),3) as avg_income
from tb_get_car_order
join tb_get_car_record using(order_id )
where driver_id in(
    #统计2021年国庆7天期间在北京市接单至少3次的司机
    select
        driver_id
    from tb_get_car_order
    join tb_get_car_record using(order_id )
    where date(order_time) between '20211001' and '20211007'
    and city = '北京'
    group by driver_id having count(order_time) >= 3
)
and date(order_time) between '20211001' and '20211007'
and city = '北京'

发表于 2022-12-03 17:16:47 回复(1)

Mysql

啊坡糍嘚

select 
    t.city
    ,round(count(order_id)/count(distinct driver_id),3) as avg_order
    ,round(sum(fare)/count(distinct driver_id),3) as avg_fare
from 
    (select 
         a.city,b.order_id,b.driver_id,b.order_time,b.fare
         ,count(b.order_id)over(partition by driver_id) as cnt
    from tb_get_car_record a,tb_get_car_order b
        where a.order_id=b.order_id
        and substring(order_time,1,10) between '2021-10-01' and '2021-10-07'
        and a.city='北京'
) t 
where cnt>=3 group by t.city

需要注意一点，在打车订单表中的记录都算接单一次，即使其符合“上车前被乘客或司机取消了这一条件”也算接单一次，所以不能用is not null 来剔除。

发表于 2022-03-24 16:10:32 回复(0)

好想找个活养家

/*用户提交打车请求后，在用户打车记录表生成一条打车记录，order_id-订单号设为null；
当有司机接单时，在打车订单表生成一条订单，填充order_time-接单时间及其左边的字段，start_time-开始计费的上车时间及其右边的字段全部为null，并把order_id-订单号和order_time-接单时间（end_time-打车结束时间）写入打车记录表；若一直无司机接单，超时或中途用户主动取消打车，则记录end_time-打车结束时间。
若乘客上车前，乘客或司机点击取消订单，会将打车订单表对应订单的finish_time-订单完成时间填充为取消时间，其余字段设为null。
当司机接上乘客时，填充订单表中该start_time-开始计费的上车时间。
当订单完成时填充订单完成时间、里程数、费用；评分设为null，在用户给司机打1~5星评价后填充。
问题：请统计2021年国庆7天期间在北京市接单至少3次的司机 用WHERE EXISTS 表示
的平均接单数和平均兼职收入（暂不考虑平台佣金，直接计算完成的订单费用总额），结果保留3位小数。*/
SELECT   tgcr1.city
	   , ROUND(COUNT(tgco1.order_time)/COUNT(DISTINCT tgco1.driver_id),3) AS avg_order_num
       , ROUND(SUM(tgco1.fare)/COUNT(DISTINCT tgco1.driver_id),3) AS avg_income
  FROM tb_get_car_order AS tgco1 LEFT JOIN tb_get_car_record AS tgcr1
	ON tgco1.order_id=tgcr1.order_id
 WHERE tgcr1.city='北京'
   AND tgco1.order_time BETWEEN '2021-10-01' AND '2021-10-07'
   AND EXISTS(SELECT 1
			    FROM tb_get_car_order AS tgco2 LEFT JOIN tb_get_car_record AS tgcr2
                  ON tgco2.order_id=tgcr2.order_id
			   WHERE tgco1.driver_id=tgco2.driver_id
                 AND tgcr2.city='北京'
				 AND tgco2.order_time BETWEEN '2021-10-01' AND '2021-10-07'
			   GROUP BY tgco2.driver_id
			  HAVING COUNT(tgco2.order_time)>=3)
/*子查询写法更简单
SELECT tmp.city, SUM(tmp.order_cnt)/COUNT(tmp.driver_id), SUM(tmp.fare_tmp)/COUNT(tmp.driver_id)
  FROM (SELECT   tgco1.driver_id, tgcr1.city
	           , COUNT(tgco1.order_time) AS order_cnt
			   , SUM(tgco1.fare) AS fare_tmp
		  FROM tb_get_car_order AS tgco1 LEFT JOIN tb_get_car_record AS tgcr1
			ON tgco1.order_id = tgcr1.order_id
		 WHERE tgco1.order_time BETWEEN '2021-10-01' AND '2021-10-07'
		   AND tgcr1.city='北京'
		 GROUP BY tgco1.driver_id
	    HAVING COUNT(tgco1.order_time)>=3) AS tmp*/

发表于 2022-01-09 14:18:47 回复(0)

Mysql

冷凡社长

select city,round(avg(num),3) as avg_order_num , round(avg(sum1),3) as avg_income from (
select driver_id,city,count(*) as num ,sum(fare) as sum1
from tb_get_car_record join tb_get_car_order using(order_id)
     where  city='北京' and date(order_time) between '2021-10-1'and '2021-10-7'
group by driver_id ,city

having count(*)>=3  )t
group by city

接单就算

注意条件，北京、国庆，接单量>=3

发表于 2022-08-26 16:36:07 回复(1)

瓶子不是天才

SELECT 
city,
ROUND(avg(order_cnt), 3) AS avg_order_num,
ROUND(SUM(income_cnt) / COUNT(driver_id), 3) AS avg_income
FROM
    (SELECT 
          city,
          driver_id,
          COUNT(order_time) AS order_cnt,
          SUM(fare) AS income_cnt
     FROM tb_get_car_order 
     JOIN tb_get_car_record
     USING(uid)
     WHERE DATE(order_time) BETWEEN '2021-10-01' AND '2021-10-07'
     AND city = '北京'
    GROUP BY city, driver_id
    HAVING order_cnt >= 3) AS t
GROUP BY city

为什么这个测试能过，提交答案确实错的呢？输出“北京、4.500、121、250”

发表于 2022-01-24 16:14:52 回复(5)

黯淡蓝点_

with driver as(
select city,driver_id,count(driver_id) as order_num,sum(fare) as income
from tb_get_car_order a 
left join tb_get_car_record b using(order_id)
where date(order_time) between '2021-10-01' and '2021-10-07' and city = '北京'
group by 1,2
having order_num>=3
)


select city,round(avg(order_num),3) as avg_order_num,round(avg(income),3) as avg_income
from driver
group by city

发表于 2025-05-03 22:50:45 回复(0)

爱刷美剧的柯基在许愿

select c,round(avg(o),3),round(avg(f),3)
from(select city c,driver_id d,count(order_id) o,sum(fare) f
    from tb_get_car_record
    join tb_get_car_order using(order_id)
    where city='北京'
    and date(order_time) between '2021-10-01' and '2021-10-07'
    group by 1,2
    having o>2) a
group by 1;

方法二：

select distinct city
,round(avg(count(order_time)) over(),3) 
,round(avg(sum(fare)) over(),3) 
from tb_get_car_record 
join tb_get_car_order using(order_id)
where date(order_time) between '2021-10-01' and '2021-10-07'
and city = '北京'
group by city,driver_id
having count(order_time) >= 3;

发表于 2024-08-03 16:00:16 回复(0)

好奇的打工鸭在泡澡

select city,round(avg(total_order),3) avg_order_num,
round(avg(total_fare),3) avg_income
from
(select city,driver_id,count(*) over(partition by driver_id) total_order,
sum(fare) over(partition by driver_id) total_fare
from tb_get_car_record a,tb_get_car_order b
where a.order_id=b.order_id and date(order_time) between '2021-10-01' and '2021-10-07' and city='北京'
)t
where total_order>=3 
group by city;

发表于 2024-04-13 18:20:33 回复(0)

Mysql

牛客726843595号

select city,
        round(count(order_id)/count(distinct(driver_id)) ,3) as avg_order_num,
        sum(fare)/count(distinct(driver_id)) as avg_income
from tb_get_car_order
left join tb_get_car_record using(order_id)
where city='北京'  and driver_id in (select driver_id
                                    from tb_get_car_order
                                    group by driver_id
                                    having count(order_id)>=3)
        and  DATE(order_time) BETWEEN '2021-10-01' AND '2021-10-07'

求问大佬，为什么这个测试能过，提交输出的结果是错的呢？实际输出

北京

2.500

81.500

发表于 2024-03-11 16:04:42 回复(0)

Mysql

War张

select distinct
    city,
    round(avg(count(order_time)) over(),3) avg_order_num,
    round(avg(sum(fare)) over(),3) avg_income
from tb_get_car_record t1
join tb_get_car_order t2
on t1.order_id = t2.order_id
where date(order_time) between '2021-10-01' and '2021-10-07'
and city = '北京'
group by city,driver_id
having count(order_time) >= 3;

发表于 2023-11-05 21:51:22 回复(0)

淅沥Z6

select
city
,round(avg(count_order_id),3) avg_order_num
,round(avg(sum_fare),3) avg_income
from (
    select
    city
    ,count(o.order_id) count_order_id
    ,sum(fare) sum_fare
    from
    tb_get_car_record r join tb_get_car_order o
    on r.order_id=o.order_id
    where
    city="北京"
    and date(order_time) between '2021-10-01' and '2021-10-07'
    group by o.driver_id
    having count(o.order_id)>=3
) t
group by city

发表于 2023-06-13 19:46:29 回复(0)

海底的星星fly

select '北京'as city,
round(sum(order_num)/count(driver_id),3) as avg_order_num,
round(sum(income)/count(driver_id),3) as avg_income
from
(
select driver_id,count(order_id) as order_num,
sum(fare) as income
from tb_get_car_order 
where
date(order_time) between date('2021-10-01') and date('2021-10-07')
and
order_id in(select order_id from tb_get_car_record where city='北京')
group by driver_id
having order_num>=3
) as tb;

发表于 2023-02-24 12:45:54 回复(0)

Mysql

lool.

SELECT # 计算目标值
	city
	,ROUND(SUM(order_cnt) / COUNT(DISTINCT driver_id),3) AS avg_order_num
	,ROUND(SUM(total_fare) / COUNT(DISTINCT driver_id),3) AS avg_income
FROM
	(
	SELECT # 两表拼接 加入city字段
		driver_id   # 分组计算各个司机的order_time数 + 总fare
		,city
		#,order_time
		,count(order_time) as order_cnt
		,SUM(fare) as total_fare
		#,ROUND(count(order_time)/COUNT(DISTINCT driver_id) ,3 ) AS avg_order_num
		#,ROUND(SUM(fare)/COUNT(DISTINCT driver_id) ,3 )AS avg_income
	FROM
		tb_get_car_record as a
	JOIN
		tb_get_car_order as b
	USING (order_id)
	WHERE city = '北京'
		AND order_time BETWEEN '2021-10-01 00:00:00' AND '2021-10-07 23:59:59'
	GROUP BY driver_id
	HAVING
		count(order_time) >=3
	) AS t
GROUP BY city

发表于 2022-09-04 20:50:48 回复(0)

Mysql

还是用小北吧

取消的订单也算订单,😓理解能力

发表于 2022-03-25 22:39:15 回复(2)

牛客880640151号

select k.city city,
round(avg(k.counts),3) avg_order_num,
sum(k.sum_fare)/count(1) avg_income from 
(select r.city city,sum(o.fare) sum_fare,count(o.driver_id) counts
from tb_get_car_record r join tb_get_car_order o
on r.order_id = o.order_id
where date(order_time) between '2021-10-01' and '2021-10-07'
and r.city = '北京'
group by o.driver_id
having count(o.driver_id)>=3) k
group by k.city

发表于 2021-12-21 22:56:36 回复(2)

迟缓的小饼干1

with t as (select b.driver_id,
      count(b.order_id) as total_order,
      sum(b.fare) as total_income
from tb_get_car_order as b
join tb_get_car_record as a
on b.order_id=a.order_id 
and date(b.order_time) between '2021-10-01'and '2021-10-07'
and a.city='北京'
group by 1)

select '北京' as city,
       round(avg(total_order),3) as avg_order_num,
    round(avg(total_income),3) as avg_income
from t
where total_order>=3
group by 1

国庆期间，一位司机在北京接了3单，后面的订单都是在别的城市接，那后面的这些订单也应该算进来吧

发表于 2025-07-07 14:36:57 回复(0)

浅浅的夏天_

select city,
round(avg(order_num),3) avg_order_num,
round(avg(income),3) avg_income
from
(
    select driver_id,
    city,
    count(a.order_id) order_num,
    sum(fare) income

    from tb_get_car_order a
    left join  tb_get_car_record b
    on a.order_id=b.order_id
    
    where 
    date(finish_time) between '2021-10-01' and '2021-10-07'
    and city='北京'
    group by city,driver_id
    having order_num>=3
) t1

group by 1

发表于 2025-06-27 17:22:49 回复(0)