msb_148887
/
huang
1
0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

提交tes01

Browse Source
dev
huangguoxin 8 months ago
parent 89db9197e7
commit e46335e56d
1 changed files with 531 additions and 0 deletions
Show Stats Download Patch File Download Diff File

531
api-passenger/src/test/java/com/msb/test01/test01.java
Unescape View File

@ -0,0 +1,531 @@
package com.msb.test01;
import org.junit.Test;
import java.util.*;
public class test01 {
@Test
public void test01(){
/**
* Excel单元格数值统计（java)
* 题目描述：
* excel工作表中对选定区域的数值进行统计的功能非常实用。
* 仿照Excel的这个功能，请对给定表格中选定区域中的单元格进行求和统计，并输出统计结果。
* 为简化计算，假设当前输入中每个单元格内容仅为数字或公式两种。
* 如果为数字，则是一个非负整形，形如3，77
* 如果为公式，则固定以=开头，且仅包含下面三种情况：
* 1.等于某单元格的值，例如=B12
* 2.两个单元格的双目运算（仅为+或-),形如=C1-C2,C3+B2
* 3.单元格和数字的双目运算（仅为+或-),形如B1+1,100-B2
*
* 注意：
* 1.公式内容都是合法的，例如不存在，=C+1,=C1-C2+B3,=5,=3+5
* 2.不存在循环引用，例如A1=B1+C1,C1=A1+B2
* 3,内容中不存在空格，括号
*
* 输入描述
* 第一行两个整数rows cols,表示给定表格区域的行数和列数，1<=rows<=20,1<=cols<=26.
* 接下来rows行，每行cols个以空格分隔的字符串，表示给定表格values的单元格内容。
* 最后一行输入的字符串，表示给定的选中区域，形如A1:C2.
*
* 输出描述：
* 一个整数，表示给定选中区域各单元格中数字的累加总和，范围-2147，483，648~2147483647
*
* 备注
* 表格的行号1-20，列号A-Z,例如单元格B3对应value[2][1].
*
* 输入的单元格内容（含公式）中数字均为十进制，值范围[0,100].
* 选中区域：冒号左侧单元格表示选中区域的左上角，右侧表示右下角，如可以为B2:C10,B2:B5,B2Y2,C2:A1
* 的输入。
*
*
*
*/
StringBuffer buffer = new StringBuffer();
String str = "abcdefgh";
if(str.length()<8){
buffer.append(str);
}
while(buffer.length()< 8 && str.length()<8){
buffer.append("0");
}
while(str.length()>8){
String strs =str.substring(0,8);
System.out.println(strs);
str = str.substring(8);
}
if(str.length()==8){
System.out.println(str);
}
if(str.length()<8 && buffer.length()<8){
buffer.append(str);
}
while(buffer.length()< 8 && str.length()<8 && str.length()>0){
buffer.append("0");
}
System.out.println(buffer.toString());
}
//递归方法实现
public void mergeSort1(int[] arr){
if(arr == null || arr.length <2){
return;
}
process(arr,0,arr.length -1);
}
public void process(int[] arr,int l,int r){
if(l==r){
return;
}
int mid = l + ((r -l) >>1);
process(arr,l,mid);
process(arr,mid+1,r);
merge(arr,l,mid,r);
}
public void merge(int[] arr,int l,int m,int r){
int[] help = new int[r-l+1];
int i=0;
int p1=l;
int p2= m+1;
while(p1<=m && p2<=r){
help[i++] = arr[p1]<= arr[p2]? arr[p1++]:arr[p2++];
}
//要么p1越界了，要么p2越界了
while(p1<=m){
help[i++] = arr[p1++];
}
while(p2<=r){
help[i++]=arr[p2++];
}
for(i=0;i<help.length;i++){
arr[l+i] = help[i];
}
}
//当前考虑到了index号货物，index...所有的货物可以自由选择
//做的选择不能超过背包容量
//返回最大价值
public static int process1(int[] w,int[] v,int index,int bag){
if(bag < 0){
return -1;
}
if(index == w.length){
return 0;
}
//有货，index位置的货
//bag有空间
//不要当前的货
int p1 = process1(w,v,index+1,bag);
//要当前的货
int p2=0;
int next = process1(w,v,index+1,bag-w[index]);
if(next !=-1){
p2 = v[index] + next;
}
return Math.max(p1,p2);
}
@Test
public void test02(){
String str = "0101";
int anInt = Integer.parseInt(str, 2);
System.out.println(anInt);
TreeSet<Character> set = new TreeSet<Character>();
}
public void mergeSort2(int[] arr){
if(arr == null || arr.length < 2){
return;
}
int N = arr.length;
//步长
int mergeSize = 1;
while(mergeSize < N){
// 当前左组的，第一个位置
int L = 0;
while(L < N){
int M = L + mergeSize -1;
if (M >= N) {
break;
}
int R = Math.min(M + mergeSize,N-1);
merge(arr,L,M,R);
L = R +1;
}
//防止溢出
if(mergeSize > N/2){
break;
}
mergeSize <<= 1;
}
}
public int comparator(int[] arr){
if(arr == null || arr.length <2){
return 0;
}
int res = 0;
for(int i=1;i<arr.length;i++){
for(int j=0;j<i;j++){
res += arr[j] < arr[i] ? arr[j] :0;
}
}
return res;
}
public int smallSum(int[] arr){
if(arr == null || arr.length < 2){
return 0;
}
return process3(arr,0,arr.length - 1);
}
//arr[l,r)即要排好序，也要求小和返回
//所有merge时，产生的小和，累加
//左 排序 merge
//右 排序merge
//merge
public int process3(int[] arr,int l,int r){
if(l == r){
return 0;
}
// l < r
int mid = l + ((r - l) >> 1);
return process3(arr,l,mid) + process3(arr,mid + 1,r) + merge3(arr,l,mid,r);
}
public int merge3(int[] arr,int l,int m,int r){
int[] help = new int[r-l+1];
int i=0;
int p1 = l;
int p2= m+1;
int res =0;
while(p1<= m && p2 <= r){
res += arr[p1] < arr[p2] ? (r-p2+1) * arr[p1] :0;
help[i++] = arr[p1] < arr[p2] ? arr[p1++] :arr[p2++];
}
while(p1 <= m){
help[i++] = arr[p1++];
}
while(p2 <= r){
help[i++] = arr[p2++];
}
for(i=0;i<help.length;i++){
arr[l+i] = help[i];
}
return res;
}
public int biggerTwice(int[] arr){
if(arr == null || arr.length < 2){
return 0;
}
return process4(arr,0,arr.length -1);
}
public int process4(int[] arr,int l,int r){
if(l == r){
return 0;
}
int mid = l+((r-l) >> 1);
return process4(arr,l,mid) + process4(arr,mid+1,r) +
merge4(arr,l,mid,r);
}
public int merge4(int[] arr,int l,int m,int r){
return 0;
}
@Test
public void test03(){
/**
* 返回矩阵中非1的元素个数（java)
* 题目描述
* 存在一个m*n的二维数组，其成员取值范围为0，1，2.
* 其中值为1的元素具备同化特性，每经过1s,将上下左右值为0的元素同化为1.
* 而值为2的元素，免疫同化。
*
*/
}
@Test
public void test04(){
/**
* Linux发行版的数量（java)
* 题目描述
* Linux 操作系统有多个发行版，distrowatch.com提供了各个发行版的资料。这些发行版互相
* 存在关联，例如Ubuntu基于Debian开发，而Mint又基于Ubuntu开发，
* 那么我们认为Mint同Debian也存在关联。
* 发行版集是一个或多个相关存在关联的操作系统发行版，集合内不包含没有
* 关联的发行版。
* 给你一个n*n的矩阵isConnected,其中isConnected[i][j]=1
* 表示第i个发行版和第j个发行版直接关联，而isConnected[i][j]=0表示二者不直接相连。
* 返回最大的发行版集中发行版的数量。
* 输入描述
* 第一行输入发行版的总数量N,之后每行表示各发行版间是否直接相关
* 输出描述
* 输出最大的发行版集中发行版的数量
* 备注
* 1<=N<= 200
* 用例
* 输入
* 4
* 1 1 0 0
* 1 1 1 0
* 0 1 1 0
* 0 0 0 1
* 输出 3
* 说明Debian（1）和Unbuntu（2）相关
* Mint(3)和Ubuntu(2)相关，
* EeulerOS(4)和另外三个都不相关，
* 所以存在两个发行版集，发行版集中发行版的数量分别是3和1，所以输出3.
*
*/
Scanner sc = new Scanner(System.in);
int n= sc.nextInt();
int[][] matrix = new int[n][n];
for(int i=0;i<n;i++){
for(int j=0;j< n;j++){
matrix[i][j] = sc.nextInt();
}
}
System.out.println(getResult(matrix,n));
}
public int getResult(int[][] matrix,int n){
UnionFindSet ufs = new UnionFindSet(n);
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
// j从i+1开始，是因为矩阵是对称的
if(matrix[i][j] == 1){
ufs.union(i,j);
}
}
}
// conncted的key代表某个连通分量的顶级父节点，value
//代表该连通分量下的节点个数
HashMap<Integer,Integer> connected = new HashMap<>();
for(int i=0;i<n;i++){
Integer fa = ufs.find(ufs.fa[i]);
connected.put(fa,connected.getOrDefault(fa,0)+1);
}
//返回最大节点数
return connected.values().stream().max((a,b)-> a-b).get();
}
@Test
public void test05(){
/**
* 不开心的小朋友（java)
* 题目描述
* 游戏场里增加了一批摇摇车，非常受小朋友欢迎，但是每辆
* 摇摇车同时只能有一个小朋友使用，如果没有空余的摇摇车，
* 需要排队等侯，或者直接离开，最后没有玩上的小朋友会非常不开心。
* 请根据今天小朋友的来去情况，统计不开心的小朋友数量。
* 1.摇摇车数量为N，范围是：1<=n<10;
* 2.每个小朋友都对应一个编码，编码是不重复的数学，今天小朋友的来去情况，可以使用编码表示为：
* 1 1 2 3 2 3.（若小朋友离去之前有空闲的摇摇车，则代表玩耍后离开；不考虑小朋友多次玩的情况）。小朋友
* 数量<=100
* 3.题目保证所有输入数据无异常且范围满足上述说明。
*
* 输入描述
* 第一行：摇摇车数量
* 第二行：小朋友来去情况
* 输出描述
* 返回不开心的小朋友数量
* 用例
* 输入 1
* 1 2 1 2
* 输出 0
* 说明第一行，1个摇摇车
* 第二行，1号来，2号来（排队）1号走2号走（1号走后摇摇车已有空闲，所以玩后离开）
*
* 输入 1
* 1 2 2 3 1 3
* 输出1
* 说明 第一行，1个摇摇车
* 第二行，1号来2号来（排队）2号走（不开心离开）
* 3号来（排队）1号走3号走（1号走后摇摇车已有空闲，所以
* 玩后离开）
*
*
*/
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.nextLine());
String[] kids = sc.nextLine().split(" ");
System.out.println(getResult1(n,kids));
}
public int getResult1(int n,String[] kids){
//不开心的小朋友数量
int unHappy = 0;
//已在摇摇车上的小朋友编号
HashSet<String> playing = new HashSet<>();
//正在排队的小朋友编号
LinkedList<String> waiting = new LinkedList<>();
for(String kid : kids){
if(playing.contains(kid)){
//如果kid是摇摇车上的小朋友编号，则代表kid玩好了要离开
playing.remove(kid);
//如果kid离开后，摇摇车有空位了，如果此时有人排队，则让排队的人上车玩
if(waiting.size() > 0){
playing.add(waiting.removeFirst());
}
continue;
}
//如果kid不是摇摇车上的小朋友，则检查id是不是排队的小朋友
int index = waiting.indexOf(kid);
if(index != -1){
// 如果是排队的小朋友。则说明kid没有玩到摇摇车，因此会不开心的离开
unHappy++;
waiting.remove(index);
continue;
}
//如果kid既不是摇摇车上的小朋友，也不是排队的小朋友，则是
//新来的小朋友
if(playing.size() < n){
//如果摇摇车还有空位，则直接玩
playing.add(kid);
}else{
//如果摇摇车没有空位了，则需要排队
waiting.add(kid);
}
}
return unHappy;
}
@Test
public void test06(){
/**
* 猜字谜（java)
* 题目描述
* 小王设计了一个简单的猜字谜游戏，游戏的谜面是一个错误的单词，比如nesw,
* 玩家需要猜出谜底库中正确的单词。猜中的要求如下：
* 对于某个谜面和谜底单词，满足下面任一条件都表示猜中：
* 变换顺序以后一样的，比如通过变换w和e的顺序，“nwes"跟"news”是可以
* 完全对应的；
* 字母去重以后是一样的，比如"woood"和"wood"是一样的，
* 它们去重后都是"wod"
* 请你写一个程序帮忙在谜底库中找到正确的谜底。谜面是多个单词，都需要找到对应的谜底，如果找不到的话，返回"not found"
* 输入描述
* 1.谜面单词列表，以","分隔
* 2.谜底库单词列表，以","分隔
* 输出描述
* 匹配到的正确单词列表，以","分隔
* 如果找不到，返回“not found"
* 备注
* 单词的数量N的范围：0<n<1000
* 词汇表的数量M的范围：0<M<1000
* 单词的长度P的范围：0<P<20
* 输入的字符只有小写英文字母，没有其他字符
*
*
* 用例
* 输入 conection
* connection ,today
* 输出connection
* 说明无
*
* 输入 bdni,woood
* bind,wrong,wood
* 输出 bind,wood
* 说明无
*/
Scanner sc = new Scanner(System.in);
String[] issues = sc.nextLine().split(",");
String[] answers = sc.nextLine().split(",");
System.out.println(getResult6(issues,answers));
}
public String getResult6(String[] issues,String[] answers){
ArrayList<String> ans = new ArrayList<>();
for(String issue:issues){
String str1 = getSortAndDistinctStr(issue);
boolean find = false;
for(String answer: answers){
String str2 = getSortAndDistinctStr(answer);
if(str1.equals(str2)){
ans.add(answer);
find = true;
}
}
if(!find){
ans.add("not found");
}
}
StringJoiner sj = new StringJoiner(",","","");
for(String an:ans){
sj.add(an);
}
return sj.toString();
}
public String getSortAndDistinctStr(String str){
TreeSet<Character> set = new TreeSet<>();
for(char c:str.toCharArray()){
set.add(c);
}
return set.toString();
}
}
//并查集实现
class UnionFindSet{
int[] fa;
int count;
public UnionFindSet(int n){
this.count = n;
this.fa = new int[n];
for(int i=0;i<n;i++){
this.fa[i] =i;
}
}
public int find(int x){
if(x != this.fa[x]){
return (this.fa[x] = this.find(this.fa[x]));
}
return x;
}
public void union(int x,int y){
int x_fa = this.find(x);
int y_fa = this.find(y);
if(x_fa != y_fa){
this.fa[y_fa] = x_fa;
this.count--;
}
}
}
Write Preview
Loading…
Cancel
Save