目录
1.华为
1.1全量和已占用字符集合
始定两个字符集合, 一个为全量字符集, 一个为已占用字符集。
已占用的字符集合中的字符不能再使用,要求输出剩余可用字符集。
输入描述:
输入为一个字行串,字符串中包括了全量字符集和已占用字符集。两个字符集使用@连接。@前的字符集为全量字符集,@后的字符集合为已占用字符集。
已占用字符集中的字符一定是全量字符集中的字符。字符集中的字符跟字符之间使用英文逗号分隔。
字符集中的字符表示为字符加数字,字符跟数字使用英文冒号分隔,比如a:1,表示1个a字符。字符只考虑英文字母,区分大小写,数字只考虑正整形,数量不超过 100,如果一个字符都没被占用,@标识仍然存在,例如a:3,b:5,c:2@
输出描述:
可用字符集。输出带回车换行
示例输入:
a:3,b:5,c:2@a:1,b:2
示例输出:
a:2,b:3,c:2
题解:
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Scanner;
public class main {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
String str=scan.nextLine();
String[] tmp=str.split("@");
if(tmp.length<2){
System.out.println(tmp[0]);
return;//作者:无人机大佬朱志斌
}
String[] arryOne=tmp[0].split(",");
String[] arryTwo=tmp[1].split(",");
HashMap<String,Integer> map=new LinkedHashMap();
for(int i=0;i<arryOne.length;i++){
String[] tmpOne=arryOne[i].split(":");
int cnt=Integer.valueOf(tmpOne[1]);
map.put(tmpOne[0],cnt);
}
for(int i=0;i<arryTwo.length;i++){
String[] tmpTwo=arryTwo[i].split(":");
int cnt=Integer.valueOf(tmpTwo[1]);
map.put(tmpTwo[0],map.get(tmpTwo[0])-cnt);
}
String result="";
for(Entry<String,Integer> entry:map.entrySet()){
if(entry.getValue()>0){
result=result+entry.getKey();
result=result+":";
result=result+entry.getValue();
result=result+",";}
}
char[] tmpThree=result.toCharArray();
String res="";
for(int i=0;i<tmpThree.length-1;i++){
res+=tmpThree[i];
}
System.out.println(res.toString());
}
}
1.2解析逻辑字符串
输入描述:
1.测试用例中间无空格,无需考虑空格。
2.测试用例表达式中只会出现如下字符: "0","1","(",")","&","|","!"。3.测试用例所给的输入都是合法输入,无需要考底非法输入。
4.测试用例表达式长度不会超过 128 个字符。
5.括号可以重复嵌套。
例如:
1|(1&0) 返回值:1
1&0|0&1 返回值:0
!0&1|0 返回值:1
((!0&1))|0 返回值:1
输出描述:
输出逻辑运算后的最终结果:0 或者1
1.3比特块
在一个int型整数(对应的比特流)中查找某个比特块(本题固定为5,即二进制“101”)出现的次数及首次出现位置,说明:
1.输入次数和首次出现的位置中间用空格隔开。
2.位置从0 开始,即最右边位置为 0,向左依次增加。
3.如果该int型整数中没有找到该比特块,次数返回0,位置返回-1。
4.比特位允许重复使用,如 10101 中间的比特1 可以与前面的01 组成 101,也可以与后面的 10 组成 101。
输入描述:
一个任意的十进制 int 型整数
输出描述:
在输入整数对应的二进制比特流中,比特块(101)出现的次数和首次出现的位置,次数和位置分别以十进制 int 型整数表示,中间用空格隔开
示例输入:
21
示例输出:
2 0
代码1(不确定是否AC,如有问题,求大神斧正)
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int cur = in.nextInt();
//将整数转化为二进制数
String binStr = Integer.toBinaryString(cur);//作者:海思安全总工程师程昱婷博士
//求字符串中的子串
int count=0;
int firstIndex=-1;
//方法1:从前往后(当101首次出现,flag置false,则不记录以后出现的位置)
// boolean flag = false;
// for(int i = 0; i <binStr.length()-2; i++){
// if(binStr.substring(i,i+3).equals("101")){
// count++;
// if(!flag){
// firstIndex=i;
// }
// flag = true;
// }
// }
//方法2:从后往前(不断更新首次出现的位置)
for(int i = binStr.length(); i > 2; i--){
if(binStr.substring(i-3,i).equals("101")){
count++;
firstIndex=i-3;
}
}
System.out.println(count+" "+firstIndex);
}
}
}
代码2(AC)
import java.util.Scanner;
public class bitsBlock {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int cur = in.nextInt();
//将整数转化为二进制数
String binStr = Integer.toBinaryString(cur);
//求字符串中的子串
int[] res = getNum(binStr);
System.out.println(res[0]+" "+res[1]);
}
}
public static int[] getNum(String str){
char arr[] = str.toCharArray();
int[] res = new int[2];
res[1]=-1;
boolean flag = false;
for(int i = arr.length-1; i >=2; i--){
if(arr[i]=='1'){
if(arr[i-1]=='0'&&arr[i-2]=='1'){
res[0]++;
if(!flag){
res[1]=(arr.length-1)-i;
}
flag = true;
}
}
}
return res;
}
}
1.4文本解析
某程序员小A,有一种表格数据需要存储在文件中。表格中的每行,由若干个字骤组成,每个字段可以是整数字符串(字符包数字字母以及特殊字符!@#¥%……&*()",)。小A 设计了一种存储格式,采用文本的方式对表格数据进行存储。文本文件中的每行,代表了表格数据中的行数据。具体格式如下:
1、采用号分隔不同的字段(逗号前后无空格);
2、数字直接采用 10 进制的文本存储;
3、字符串的存储规则如下:
1)如果字符串中包含逗号以及双引号,则字符串必须在头尾各增加一个双引号,且中间的双引号需要用连续两个双引号来表示。例如:"a,""b",表示字符串 a,"b
2)如果字符串中末包含逗号以及双引号,则字符串不强制要求在头尾增加双引号,可直接存储。例如:abc,或者"abc"都可以。
4、空字符串不存储任何字符,例如:a,,b中,有3 个字段,分别为a,空字符串,b;
请帮助小A 设计个算法,用来将单行文本,解析成多个字段,并输出。
输入描述:
用于存储单行表格数据的一行文本。
1、用手分隔不同字段的号前后一定没有空格,程序设计者无需考虑此种异常情况
2、除数字、字母以及特殊字符!@#¥%……&*()",外,不会出现其它字符
3、输入的数字一定是 10 进制合法正整数,不会出现负数、小数、其它进制数以及格式错误的 10 进制数
输出描述:
第一行,字符串格式是否正确,正确输出字段个数,不正确输出ERROR。
如果输入字符串格式不正确,则输出结束。如果字符串格式正确,则输出每个字段的值,每个字段单独占一行。
数字采用 10 进制输出,字符串输出解析后的值。空字符串输出--
示例输入:
a,,1,"b,"""
示例输出:
4
a
--
1
b,"
思路
如果首次遇到双引号,则将将flag置为真,之后除双引号之外的所有字符,包括逗号,全部保留;
如果再次遇到双引号,则将将flag置为假,恢复正常操作。
题解:(没有AC,只过了80%)
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
List<String> list=new ArrayList<>();
StringBuilder sb=new StringBuilder();
if(s!=null){
boolean flag=false;//作者:外星小小朋友
for(int i=0;i<s.length();i++){
char c=s.charAt(i);
if(c==','){
if(flag){
sb.append(',');
}else{
if(sb.length()==0){
list.add("--");
}else{
list.add(sb.toString());
}
sb=new StringBuilder();
}
}else if(c=='"'){
if(i+1<s.length() && s.charAt(i+1)=='"'){
sb.append('"');
i++;
}else if(flag){
list.add(sb.toString());
sb=new StringBuilder();
flag=false;
}else{
flag=true;
}
}else{
sb.append(c);
}
}
if(sb.length()!=0){
list.add(sb.toString());
}
if(flag){//作者:猴哥
System.out.println("ERROR");//作者:西瓜味的猫
}else{
System.out.println(list.size());
for(String str:list){
System.out.println(str);
}
}
}
}
}
1.5社交软件好友度
有一款社交软件 APP,假说注朋用户m人(0<m<50),用编号为 0~m-1,r[i,j]表示用i 和用户j 好友关系(r[i][j]=0 代表i和j不是好友,r[i][j]=1~9 代表是好友目数值代表熟悉程度,数值越大代表越熟悉,其中r[i][j]=r[j][i],0<=i,j<=m-1)试编制程序,输出某个特定用户i的n 度好
友(1 度好友代表直接好友,2 度好友代表好友的好友,以此类推1<=n<=10),并按推荐值降序输出好友列表(推荐值相同的好友,按好友编号升序,其中推荐值是指关系熟活度之和,比如朋户i和j是好友,且熟悉度r[i][j]=4 ,j和k是好友且熟活度小r[j][k]=6,且i和k 不是好友即r[i][k]=0,则用户k 是用户i的2 度好友且推荐值为可r[i][j]+r[j][k]=10),如果此用户i 没有n 度好友输出-1。
输入描述:
输入一个整数T,表示有T组测试数据(0<T<100)。
对于每组测试数据输入2行,
第1行 输入3 个整型数 m,i,n 分别代表用户数 m,某个用户编号 i,n度好友, 即代表本组测试需要输出用户i的n度好友
第2 行 输入1 个整型数 k,接下来 3*k 个整数用空格隔开,每三个组成关系对,每个关系由3 个整型数组成 i,j,w 代表用户主和的熟悉程度,即 r[i][j]=w,没有输入的关系默认为非好友(r[i][j]=r[j][i]=0)
输出描述:
输出T行,每行对应每组测试数据的用户i的n 度好友,按推荐值降序输出,推荐值相同的好友按好友编号升序,编号间用空格隔开。如果没有n 度好友输出-1
示例输入:
2
10 5 2
13 0 3 5 0 4 9 0 6 8 0 7 5 1 2 6 1 6 1 2 9 7 3 4
3 3 5 3 3 8 3 3 9 3 5 8 9 7 8 9
10 0 2
13 0 3 5 0 4 9 0 6 8 0 7 5 1 2 6 1 6 1 2 9 7 3 4
3 3 5 3 3 8 3 3 9 3 5 8 9 7 8 9
示例输出:
7 0 4 9
1 5 8 9
代码:暂无
2.360
2.1表面积
将长N*M 厘米的矩形区域划分成N行M 列(每行每列的宽度均为1 厘米),在第i行第j列的位置上叠放Ai,j个边长为1 厘米的正方体(1≤Ai,j≤100),所有正方体就组成了一个立体图形,每个正方体六个面中的一部分会被其它正方体遮挡,未被遮挡的部分的总面积即为该立体图形的表面积,那么该立体图形的表面积是多少平方厘米?
输入描述:
第一行包含两个整数N和M,1≤N,M≤1000。
接下来N行,每行包含M个整数,第i行的第j个整数表示 Ai,j
输出描述:
输出表面积的大小。
示例输入:
2 2
2 1
1 1
示例输出
20
题解:
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[][] grid=new int[n][m];
for(int i=0;i<grid.length;i++){
for(int j=0;j<grid[0].length;j++){
grid[i][j]=sc.nextInt();
}
}
int res=surfaceArea(grid);
System.out.println(res);
}
public static int surfaceArea(int[][] grid){
int surface1 = 0; //记录每个位置上组合立方体的表面积
int surface2 = 0; //记录每个位置上组合立方体的邻接面积
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] != 0) {
surface1 += grid[i][j] * 4 + 2; //记录当前位置上组合立方体的表面积
}
if (i != grid.length - 1) {
//记录 i 行与 i + 1 行的邻接面积
surface2+=(grid[i][j]>grid[i+1][j]?grid[i+1][j]:grid[i][j])*2;
}
if (j != grid[0].length - 1) {//作者:孙作者
//记录 j 列与 j + 1 列的邻接面积
surface2+=(grid[i][j]>grid[i][j+1]?grid[i][j+1]:grid[i][j])*2;
}
}
}
return surface1 - surface2;
}
}
2.2寻找子串
英语老师看你老是在英语课上和周围同学交头接耳,所以给你布置了一份额外的家庭作业来惩罚惩罚你:你有一个字符串 s,请你在s 的所有子串中,找到出现次数最多的子串,告诉老师它的出现次数。
输入
共一行,一个字符串 s,仅由英文小写字母组成,1<|s|<10000。
输出
一个正整数,表示最大出现次数。
样例输入
aba
样例输出
2
思路1:求出全部子串,然后统计,但是这样会内存超限;
思路2:只统计长度为1的子串即可,即判断字符串中每个char出现的次数。因为长度大于1的子串出现的次数必然小于长度大于1的子串出现的次数,故省略不计。
2.3散步
饭后散步是个很好的习惯,一天晚上,小A 在条笔直的路上散步,起点在路上某处,但是因为路上没有标识,他并不知道这个起点位于路上的哪个位置,现在将道路划分为 N-1 个等距的部分,你可以把这条路当成一个数轴,道路上的结点标记为 1~N,起点只可能是这N 个点中的一个。
但是小A 还提供了一个重要信息,他每隔一段时间就会用手机看一下自己走了多远,记作D,但是他并不记得他是朝着哪个方向走的,唯一可以确定的是,在两次看手机的间隔中他不会改变方向,每次看完手机后他可能继续向前或者回头走。
那么问题来了,已知他在散步过程中始终在 1~N 的范围内,那么符合上述条件的终点可能有多少个呢?
输入
输入第一行包含一个正整数 N,M,N 表示道路的长度,也是数轴上点的数量,M 是小A提供的D 的数量。(N,M<=20000)
接下来有M行,每行一个正整数D,表示小A 朝着某个方向走了D 个单位。(D<=20000)
输出
输出仅包含一个整数,表示可能的起点的数量。
输入样例
10 3
5
2
6
输出样例
8
代码
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[] loc=new int[m];
int count=0;
for (int i = 0; i < m; i++) {
loc[i]=sc.nextInt();
}
for(int j=1;j<=n;j++){
if(panduan(j,n,loc)){
count++;
}
}
System.out.println(count);
}
public static boolean panduan(int i,int n,int[] loc){
boolean result=false;
for(int j=0;j<loc.length;j++){
if(i+loc[j]<=n){
i+=loc[j];
result=true;
continue;
}else if(i-loc[j]>=1){
i-=loc[j];
result=true;
continue;
}else{
result=false;
return result;
}
}
return result;
}
}
3.京东
3.1最多能完成排序的块
参考力扣768
3.2考场安排
某校在积极推行无人监考制度,但是总有学生是不自觉的,如果将两个很熟的异性朋友放在同一个考场里,他们就会交流甚至作弊。因此一个考场中不能允许两个很熟的异性朋友存在,学校希望通过搬出一部分学生的方法来改善这一问题。但是又因为教率数量有限,因此希望个教率中容下的学生尽可能多,即需要搬出教室的学生数量尽可能少,请你输出搬出教室人数最少,且字典序最小的方案。
输入描述
输入第行有两个整数n和 m,分别表示有n 个男生和n 个女生,有m 个朋友关系。
(1<=n<=500,1<=m<=100000
接下来m行,每行有两个整数,x和 y,表示第号男生和第y 号女生是朋友。男生的编号均为[1,n],女生的编号为[n+1,2n]
输出描述
输出第一行包含一个整数 a,表示最少需要搬出教室的人数。
输出第二行有a 个整数,即a 个需要搬出教室的人的编号,要求人数最少,且字典序最小
样例输入
2 2
3 1
1 4
样例输出
1
3
代码
import java.util.HashMap;
import java.util.Scanner;
public class testOne {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int m=scan.nextInt();
n=n*2;
HashMap<Integer,Integer> count=new HashMap<>();
int[][] relation=new int[n+1][n+1];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
relation[i][j]=0;
for(int i=0;i<m;i++){
int tmp1=scan.nextInt();
int tmp2=scan.nextInt();
if(count.get(tmp1)!=null){
count.put(tmp1, count.get(tmp1)+1);
relation[tmp1][tmp2]=1;
relation[tmp2][tmp1]=1;
}
else{
count.put(tmp1, 1);
relation[tmp1][tmp2]=1;
relation[tmp2][tmp1]=1;
}
}
int[] array=new int[10000];
int loc=0;
int k=-1;
String s="";
while(panduan(relation,n+1)){
loc=location(count,n+1);
count.put(loc,0);
array[++k]=loc;
for(int i=1;i<n+1;i++)
for(int j=1;j<n+1;j++)
if(i==loc||j==loc)
relation[i][j]=0;
}
int num=0;
for(int i=0;i<array.length;i++)
if(array[i]>0)
num++;
System.out.println(num);
for(int i=0;i<num-1;i++)
System.out.print(array[i]+" ");
System.out.println(array[num-1]);
}
public static int location(HashMap<Integer,Integer> count,int n){
int max=0;
int maxIndex=0;
for(int i=0;i<=n;i++){
if(count.get(i)!=null && count.get(i)>max){
max=count.get(i);
maxIndex=i;
}
}
return maxIndex;
}
public static boolean panduan(int[][] relation,int n){
for(int i=1;i<n;i++)
for(int j=1;j<=i;j++)
if(relation[i][j]==1)
return true;
return false;
}
}
4.中兴
4.1工资按频次排序
给N名员工的工资清单,按照工资分布的人数降序排序,如果有两个工资的人的数目一致(大概意思就是假设3000工资有3个人,5000也是三个人),就按照工资在给定清单的顺序里面排序。
输入
20(人数)
4 1 4 4 2 1 2 3 1 9 1 2 8 7 5 6 3 4 3 6
输出
4 4 4 4 1 1 1 1 2 2 2 3 3 3 6 6 9 8 7 5
代码
/*
1.用Map来统计工资及其出现的频次,由于需要对频次相同的工资按照原来的顺序打印,所以需要使用到是LinkedHashMap,Key为工资,Value为出现频次;
2.用Map的EntrySet构造List, 并对list按照工资出现频次排序;
3.将上述List从头到尾添加至结果集List中,频次为n,则重复添加n次。
*/
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int num=sc.nextInt();
int[] nums=new int[num];
for(int i=0;i<num;i++){
nums[i]=sc.nextInt();
}
List<Integer> salaryList=sortSalary(nums);
for(int i:salaryList){
System.out.print(i+" ");
}
}
public static List<Integer> sortSalary(int[] nums){
//一维数组salaryList用于存放排序后的工资列表。
List<Integer> salaryList = new ArrayList();
//freMap用于统计工资出现的凭此,key为工资,value为出现频次
Map<Integer,Integer> freMap = new LinkedHashMap<Integer, Integer>();
//二维数组tempList用于存放带频次信息的工资列表,tempList[i][0]存放工资,tempList[i][1]存放频次
List<Map.Entry<Integer,Integer>> tempList = null;
//统计频次
for(int i=0;i<nums.length;i++){
if(freMap.containsKey(nums[i])){
freMap.put(nums[i],freMap.get(nums[i])+1);
}else {
freMap.put(nums[i],1);
}
}
tempList = new ArrayList(freMap.entrySet());
Collections.sort(tempList, new Comparator<Map.Entry<Integer, Integer>>() {
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o2.getValue()-o1.getValue();
}
});
for(Map.Entry<Integer,Integer> entry : tempList){
for(int i=0;i<entry.getValue();i++){
salaryList.add(entry.getKey());
}
}
return salaryList;
}
}
参考:https://blog.csdn.net/weixin_44003141/article/details/98882568
4.2维克多博士问题
https://blog.csdn.net/hongtao_6/article/details/97246319
5.快手
5.1可以升级的版本号
给定两个版本号,只有在版本号更高的时候,才可以升级。
输入
2
6.6.6 6.6.7
1 1.0
输出
true
false
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int caseNum = Integer.valueOf(sc.nextLine());//sc每接收一种类型的数据就要new一个新的Scanner类
boolean[] canUpgradeArr=new boolean[caseNum];
for(int i=0;i<caseNum;i++) {
String line = sc.nextLine();
String[] versionArr = line.split(" ");
canUpgradeArr[i]=canUpgrade(versionArr[0],versionArr[1]);
}
for (boolean b : canUpgradeArr) {
System.out.println(b);
}
}
public static boolean canUpgrade(String oldVersion,String newVersion) {
String[] oldVersionArr = oldVersion.split("\\.");
String[] newVersionArr =newVersion.split("\\.");
int maxLen = Math.max(oldVersionArr.length, newVersionArr.length);
for(int i=0;i<maxLen;i++) {
int curOld = i<oldVersionArr.length?Integer.valueOf(oldVersionArr[i]):0;
int curNew = i<newVersionArr.length?Integer.valueOf(newVersionArr[i]):0;
if(curOld!=curNew) {
return true;
}
}
return false;
}
}
5.2计算累计平方和
参考力扣202
5.3合并两个内容流
5.4好序列
6字节跳动
6.1豆油瓶
抖音上每天都有几亿用户,如果用户A和B 互动不少于3次,我们就认为A和B 属于“豆油”,如果A和B “豆油”,B和C 的是“豆油”,那么A和C 也互为“豆油”,我们定义“豆油瓶”就是由直系和间接朋友组成的群体。
给定1个N*N 的矩阵M,代表抖音上所有用户的互动次数,如果M[i][j]=5,那么第i个和第j个用户就互动过5次,为0 的话代表没有互动其中,对i=j,即同一个用户,互动次数我们计为0.请你计算并输出发现的抖音上所有“豆油瓶”的个数。
输入
示例1:
3
0 4 0
4 0 0
0 0 0示例2:
3
0 4 0
4 0 6
0 6 0
输出
示例1:
2
示例2:
1
代码
import java.util.Scanner;
public class Main {
//求无向连通子图个数
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int userNum=sc.nextInt();
int[][] grid=new int[userNum][userNum];
for(int i=0;i<userNum;i++){
for(int j=0;j<userNum;j++){
if(sc.nextInt()>=3){
grid[i][j]=1;
}
}
}
//已经遍历过的用户
boolean[] visited=new boolean[grid.length];
int res=0;
for(int i=0;i<grid.length;i++){
if(!visited[i]){
res++;
dfs(i,grid,visited);
}
}
System.out.println(res);
}
public static void dfs(int i,int[][] grid,boolean[] visited){
visited[i]=true;
for(int j=0;j<grid.length;j++){
if(!visited[j] && grid[i][j]==1){
dfs(j,grid,visited);
}
}
}
}
6.2求圆形花园不相交的路
圆形花园共有n个入口,现在要修路,穿过花园,要求每个路口只能有一条路,所有路均不会相交,求所有可行的方法总数。
思路:
卡特兰数
6.3 2048
7.阿里
7.1小明和他的朋友们
代码
import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Main1 {
private static HashSet<Integer> set = null;
/** 请完成下面这个函数,实现题目要求的功能 **/
/** 当然,你也可以不按照这个模板来作答,完全按照自己的想法来 ^-^ **/
static String getIndexAndLongest(String users,int k) {
if(users==null) {
return "0 0";
}
set = new HashSet<>();
for(int i=0;i<users.length();i++) {
if(users.charAt(i)=='b') {
set.add(i);
}
}
String idx = getIndex(users);
String longest = getLongest(users, k);
return idx+" "+longest;
}
private static String getLongest(String users,final int k) {
int size = users.length();
int maxBoy = 0;
for(int i=0;i<size;i++) {
int start = (i+1)%size;
int count = 0;
int boy = users.charAt(i)=='b'?1:0;
while(count<=k&&start!=i) {
if(users.charAt(start)=='g') {
count++;
} else {
boy++;
}
start = (start+1)%size;
maxBoy = Math.max(boy, maxBoy);
}
}
return maxBoy+"";
}
private static String getIndex(String users) {
int size = users.length();
int maxGril = 0;
int minIdx = Integer.MAX_VALUE;
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()) {
Integer entry = iterator.next();
int idx = entry;
int left = (idx+size-1)%size;
int right = (idx+1)%size;
int leftCount = 0;
int rightCount =0;
while(users.charAt(left)=='g'&&left!=right) {
left = (left-1+size)%size;
leftCount++;
}
while(users.charAt(right)=='g'&&right!=left) {
right = (right+1)%size;
rightCount++;
}
int count = leftCount+rightCount;
if(maxGril<count) {
minIdx = entry;
maxGril = count;
} else if(maxGril==count&&minIdx>entry) {
minIdx = entry;
}
}
return minIdx+"";
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String res;
String _users;
int k = 0;
try {
_users = in.nextLine();
String str = in.nextLine();
k = Integer.valueOf(str);
} catch (Exception e) {
_users = null;
}
res = getIndexAndLongest(_users,k);
System.out.println(res);
}
}
8.拼多多
8.1小梅的扑克游戏
产品经理小梅喜欢和他的男朋友小白一块玩扑克游戏。每一局,小梅抽取N 张扑克牌,自左向右依次排列在桌面上;小白也抽取 M(8>=N>=M=1)张扑克牌,自左向右依次排列在桌面上。
小梅需要进行N 个回合,使用手中的扑克牌,组成一个新的扑克牌的序列。每个回合,小梅有d、l、r三种策略:
----选择d时,小梅将最左边的扑克牌丢弃
----选择l时,小梅将最左边的扑克牌取出,放到新的扑克牌序列的最左边
----选择r时,小梅将最左边的扑克牌取出,放到新的扑克牌序列的最右边
N 个回合完成,新的扑克牌序列与小白的扑克牌完全一样(只考虑数字,不考虑花色),则小梅胜出
小梅向程序员小岛提了一个需求,希望了解获胜的全部方法。简化起见,扑克牌仅包含 1-9。
输入描述
首先,输入数字s,作为局数(1<=s<=10)
每一局,分别输入两行字行串,另代表小梅的抽取的扑克牌 (从左问右排列)和小白抽职到的扑克(从左向右排列)
输出描述
对于每一局,在开始和结束,分别输出 { 和 }
输出获胜的方法,回合策的结尾出一个空格。若存在多个获胜万法,请按宇典序的升序输出。
代码
8.2骰子期望
8.3乘法表第K大的数
9.腾讯
9.1求序列中子序列的和与子序列中的最小数最大乘积
10.VIVO
1.跳跃游戏||:参考力扣
2.约瑟夫环
3.背包问题变种:将数组分成两部分使得两部分的和的差最小