2026华为OD面试题022：分辨率排序

题目描述

视频清晰度有 4 个档位，每个档位对应一个最小的宽×高门槛：

• 4K：3840 × 2160
• 2K：2560 × 1440
• 1080P：1920 × 1080
• 720P：1280 × 720

档位大小关系：720P < 1080P < 2K < 4K。

给定任意一个分辨率（宽×高），匹配档位的规则是：宽和高要同时大于等于某个档位的最小宽高，才算满足该档位，并且优先往高里匹配。

举个例子，2600x1400：

• 4K 门槛 3840×2160：2600 < 3840，不满足
• 2K 门槛 2560×1440：2600 >= 2560，但 1400 < 1440，不满足
• 1080P 门槛 1920×1080：2600 >= 1920 且 1400 >= 1080，满足

所以2600x1400算 1080P。

还有三条特殊规则：

1. 所有低于 720P 的分辨率，统统算 720P。
2. 最大档位就是 4K，只要满足 4K 标准，再大也算 4K。
3. 不考虑交换宽高。比如2500x3200，宽不够 2K 但高够，也只能往下匹配成 1080P，不能算 2K。

分辨率大小比较规则：

1. 先比档位，档位高的排前面。
2. 档位相同比面积（宽×高），面积大的排前面。
3. 面积还相同比宽，宽大的排前面。

输入：n 组 “宽x高” 字符串，空格间隔，n < 10。

输出：从大到小排序后输出。

原题文件在输入输出示例处截断，这里按常见题型补全：输出按空格间隔排在一行。

讲个故事：产品经理的清晰度需求

小李在视频平台做后端。有天产品经理丢过来一串分辨率：2600x1400 1920x1080 3840x2160 1280x720，说"按清晰度从高到低排一下，前端要展示给用户选"。

小李心想，这不就是排序嘛，按面积排不就完了？

结果产品经理补了一句：“2600x1400这种算 1080P，不算 2K，规则我都写在文档里了。”

小李打开文档一看，档位匹配不是看面积大小，是看宽高是否同时达标，而且要从高往低试。这下有点意思了。

核心原理：定档 + 三连排序

这题拆成两步就清楚了。

第一步，给每个分辨率定档。

定档的本质是：从最高的 4K 开始往下试，宽和高同时达标才算数，第一个匹配上的就是它的档位。

• 4K：宽 >= 3840 且 高 >= 2160
• 2K：宽 >= 2560 且 高 >= 1440
• 1080P：宽 >= 1920 且 高 >= 1080
• 都不满足：算 720P（低于 720P 的也兜底成 720P）

注意是"同时"，光宽够高不够不行。所以2600x1400卡在 2K 的 1440 这道坎上，掉到 1080P。

第二步，按三连规则排序。

1. 档位高的在前（4K > 2K > 1080P > 720P）
2. 档位相同，面积（宽×高）大的在前
3. 面积也相同，宽大的在前

拿样例验证一下：

• 3840x2160：4K
• 2600x1400：1080P，面积 3,640,000
• 1920x1080：1080P，面积 2,073,600
• 1280x720：720P

排序结果：3840x2160 2600x1400 1920x1080 1280x720。两个 1080P 之间比面积，2600x1400面积更大，排前面。

怎么实现？

1. 读入所有 token，按空格切成一个个 “WxH” 字符串
2. 对每个字符串，按 x 拆出宽和高
3. 写个 getLevel 函数，从 4K 往下判断档位
4. 算面积 = 宽 × 高（用 long long 防溢出）
5. 按档位降序、面积降序、宽降序排序
6. 输出排序后的原始字符串

代码实现

C 语言

#include<stdio.h>#include<stdlib.h>#include<string.h>typedefstruct{charraw[32];intw,h;intlevel;// 4K=4, 2K=3, 1080P=2, 720P=1longlongarea;}Res;intgetLevel(intw,inth){if(w>=3840&&h>=2160)return4;if(w>=2560&&h>=1440)return3;if(w>=1920&&h>=1080)return2;return1;}intcmp(constvoid*a,constvoid*b){constRes*x=a,*y=b;if(x->level!=y->level)returny->level-x->level;// 档位降序if(x->area!=y->area)returnx->area<y->area?1:-1;// 面积降序returnx->w<y->w?1:-1;// 宽降序}intmain(){charbuf[4096];size_tlen=fread(buf,1,sizeof(buf)-1,stdin);buf[len]='\0';Res arr[16];intn=0;char*tok=strtok(buf," \t\r\n");while(tok){strcpy(arr[n].raw,tok);chart[32];strcpy(t,tok);for(char*p=t;*p;++p)if(*p=='X')*p='x';intw=0,h=0;sscanf(t,"%dx%d",&w,&h);arr[n].w=w;arr[n].h=h;arr[n].level=getLevel(w,h);arr[n].area=(longlong)w*h;n++;tok=strtok(NULL," \t\r\n");}qsort(arr,n,sizeof(Res),cmp);for(inti=0;i<n;i++)printf("%s%c",arr[i].raw,i+1<n?' ':'\n');return0;}

C++

#include<bits/stdc++.h>usingnamespacestd;intgetLevel(intw,inth){if(w>=3840&&h>=2160)return4;if(w>=2560&&h>=1440)return3;if(w>=1920&&h>=1080)return2;return1;}structRes{string raw;intw,level;longlongarea;};intmain(){vector<Res>v;string tok;while(cin>>tok){string t=tok;for(char&c:t)if(c=='X')c='x';intp=t.find('x');intw=stoi(t.substr(0,p));inth=stoi(t.substr(p+1));v.push_back({tok,w,getLevel(w,h),(longlong)w*h});}sort(v.begin(),v.end(),[](constRes&a,constRes&b){if(a.level!=b.level)returna.level>b.level;if(a.area!=b.area)returna.area>b.area;returna.w>b.w;});for(inti=0;i<(int)v.size();i++)cout<<v[i].raw<<" \n"[i+1==(int)v.size()];return0;}

Java

importjava.util.*;publicclassMain{staticintgetLevel(intw,inth){if(w>=3840&&h>=2160)return4;if(w>=2560&&h>=1440)return3;if(w>=1920&&h>=1080)return2;return1;}staticclassRes{Stringraw;intw,level;longarea;Res(Strings){raw=s;String[]sp=s.split("[xX]");w=Integer.parseInt(sp[0]);inth=Integer.parseInt(sp[1]);level=getLevel(w,h);area=(long)w*h;}}publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);List<Res>list=newArrayList<>();while(sc.hasNext()){list.add(newRes(sc.next()));}list.sort((a,b)->{if(a.level!=b.level)returnb.level-a.level;if(a.area!=b.area)returnLong.compare(b.area,a.area);returnInteger.compare(b.w,a.w);});StringBuildersb=newStringBuilder();for(inti=0;i<list.size();i++){if(i>0)sb.append(' ');sb.append(list.get(i).raw);}System.out.println(sb);}}

JavaScript

functiongetLevel(w,h){if(w>=3840&&h>=2160)return4;if(w>=2560&&h>=1440)return3;if(w>=1920&&h>=1080)return2;return1;}functionsolve(tokens){constlist=tokens.map(s=>{const[w,h]=s.split(/[xX]/).map(Number);return{raw:s,w,level:getLevel(w,h),area:w*h};});list.sort((a,b)=>{if(a.level!==b.level)returnb.level-a.level;if(a.area!==b.area)returnb.area-a.area;returnb.w-a.w;});returnlist.map(r=>r.raw).join(' ');}constfs=require('fs');constinput=fs.readFileSync(0,'utf8');consttokens=input.trim().split(/\s+/).filter(Boolean);console.log(solve(tokens));

Python

importsysdefget_level(w,h):ifw>=3840andh>=2160:return4ifw>=2560andh>=1440:return3ifw>=1920andh>=1080:return2return1defmain():tokens=sys.stdin.read().split()parsed=[]forsintokens:w,h=map(int,s.lower().split('x'))parsed.append((get_level(w,h),w*h,w,s))# 档位降序、面积降序、宽降序parsed.sort(key=lambdax:(-x[0],-x[1],-x[2]))print(' '.join(p[3]forpinparsed))main()

复杂度分析

• 解析 n 个分辨率：O(n)
• 排序：O(n * log n)
• 总时间复杂度：O(n * log n)，题目里 n < 10，基本是常数级
• 空间复杂度：O(n)

总结一下

这题看着是排序，真正的考点在档位匹配规则。

套路就两步：

1. 定档：从 4K 往下试，宽高同时达标才算数，两个兜底（低于 720P 算 720P，高于 4K 算 4K），不交换宽高
2. 排序三连：档位、面积、宽，全部降序

容易踩的坑是把"宽高同时达标"看成"宽或高达标"，或者拿面积直接定档。2600x1400就是专门用来骗这个的，面积比 1080P 大，但卡在 2K 的 1440 高度上，只能算 1080P。

你做这种带规则的排序题，是先把规则理清再写代码，还是先写个朴素排序再说？欢迎在评论区聊聊。