信息社会，有海量的数据需要分析处理，比如公安局分析身份证号码、 QQ 用户、手机号码、银行帐号等信息及活动记录。
采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。
数据范围：
，输入的整数大小满足 
[编程题]数据分类处理
- 热度指数：173290 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
- 算法知识视频讲解
输入描述:
一组输入整数序列I和一组规则整数序列R，I和R序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0~(2^31)-1，序列个数不限
输出描述:
从R依次中取出R<i>，对I进行处理，找到满足条件的I
： I
整数对应的数字需要连续包含R<i>对应的数字。比如R<i>为23，I 为231，那么I 包含了R<i>，条件满足 。 按R<i>从小到大的顺序:
(1)先输出R<i>；
(2)再输出满足条件的I
的个数； (3)然后输出满足条件的I
在I序列中的位置索引(从0开始)； (4)最后再输出I
。 附加条件：
(1)R<i>需要从小到大排序。相同的R<i>只需要输出索引小的以及满足条件的I
，索引大的需要过滤掉 (2)如果没有满足条件的I
，对应的R<i>不用输出 (3)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
序列I：15,123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123（第一个15表明后续有15个整数）
序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）
输出：30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123,6,7,1,456,2,786,4,46,8,665,9,453456,11,456,12,786
说明：
30----后续有30个整数
3----从小到大排序，第一个R<i>为0，但没有满足条件的I
，不输出0，而下一个R<i>是3 6--- 存在6个包含3的I
0--- 123所在的原序号为0
123--- 123包含3，满足条件
示例1
输入
15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123 5 6 3 6 3 0
输出
30 3 6 0 123 3 453 7 3 9 453456 13 453 14 123 6 7 1 456 2 786 4 46 8 665 9 453456 11 456 12 786
说明
将序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）排序去重后，可得0,3,6。 序列I没有包含0的元素。 序列I中包含3的元素有：I[0]的值为123、I[3]的值为453、I[7]的值为3、I[9]的值为453456、I[13]的值为453、I[14]的值为123。 序列I中包含6的元素有：I[1]的值为456、I[2]的值为786、I[4]的值为46、I[8]的值为665、I[9]的值为453456、I[11]的值为456、I[12]的值为786。 最后按题目要求的格式进行输出即可。
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] I = new int[n];
for (int i = 0; i < I.length; i++) {
I[i] = scanner.nextInt();
}
int m = scanner.nextInt();
int[] R = new int[m];
for (int i = 0; i < R.length; i++) {
R[i] = scanner.nextInt();
}
solution(I, R);
}
private static void solution(int[] I, int[] R) {
//去重排序
int[] array = IntStream.of(R).distinct().toArray();
Arrays.sort(array);
//输出的总数字
int all = 0;
StringBuilder builder = new StringBuilder();
for (int j : array) {
int count = 0;
StringBuilder stringBuilder = new StringBuilder();
for (int index = 0; index < I.length; index++) {
if (String.valueOf(I[index]).contains(String.valueOf(j))) {
stringBuilder
.append(index)//索引和值
.append(" ")
.append(I[index])
.append(" ");
count++;
}
}
if (count == 0) continue;
builder
.append(j)//输出R<i>
.append(" ")
.append(count)//输出满足条件的I的个数
.append(" ")
.append(stringBuilder);
all = all + 2 + count * 2;
}
System.out.println(all + " " + builder.toString().trim());
}
}
发表于 2024-11-09 22:33:34
回复(0)
import java.util.Scanner;
import java.util.HashMap;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int Inum = in.nextInt(), i = 0, j, count = 0;
int[] result = new int[10000]; // 存储最终输出的结果
int[] I = new int[Inum]; // 存储序列I
for (i = 0; i < Inum; i++) {
I[i] = in.nextInt();
}
int Seqn = in.nextInt();
// 哈希表存储不重复的序列R，及各元素出现次数
HashMap<Integer,Integer> r = new HashMap<Integer,Integer>();
for (i = 0; i < Seqn; i++) {
r.put(in.nextInt(), 0);
}
int[] R = new int[r.size()];
i = 0;
for (Integer k: r.keySet()) {
R[i++] = k;
}
// 给R序列排序，放在R数组中
for (i = 0; i < r.size()-1; i++) {
for (j = i+1; j < r.size(); j++) {
if (R[i] > R[j]) {
count = R[i];
R[i] = R[j];
R[j] = count;
}
}
}
count = 0;
for (j = 0; j < r.size(); j++) {
for (i = 0; i < Inum; i++) {
if ((I[i]+"").contains(R[j]+"")) {
r.put(R[j], r.get(R[j])+1);
result[count++] = i;
result[count++] = I[i];
}
}
}
for (Integer k: r.keySet()) {
if (r.get(k) != 0) {
count += 2; // 需要输出R[j]和个数
}
}
System.out.print(count+" ");
count = 0; // 准备输出
for (i = 0; i < r.size(); i++) {
if (r.get(R[i]) == 0) {
continue;
} else {
System.out.print(R[i]+" "+r.get(R[i])+" ");
for (j = count; j < count+2*r.get(R[i]); j++) {
System.out.print(result[j]+" ");
}
count = j;
}
}
}
}
发表于 2024-09-18 16:50:30
回复(0)
暴力法：两个二维数组分别存储匹配到的数（索引及其数值）
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 读取I序列
int I_num = in.nextInt();
int[] arr_I = new int[I_num];
for (int i = 0; i < arr_I.length; i++) {
arr_I[i] = in.nextInt();
}
// 读取R序列，TreeSet同时去重和排序
int R_num = in.nextInt();
Set<Integer> set = new TreeSet<>();
for (int i = 0; i < R_num; i++) {
set.add(in.nextInt());
}
int[] arr_R = new int[set.size()];
int flag = 0;
for (Integer i : set.toArray(new Integer[0])) {
arr_R[flag++] = i;
}
// flags 存放每个R<i>在I中符合的数的个数，大于0则说明存在符合的数
int[] flags = new int[arr_R.length];
// 存放匹配的数的索引
int[][] indexs = new int[arr_R.length][arr_I.length];
// 存放匹配的数的数值
int[][] values = new int[arr_R.length][arr_I.length];
for (int i = 0; i < arr_R.length; i++) {
flag = 0;// 重置flag
String part = String.valueOf(arr_R[i]);
for (int j = 0; j < arr_I.length; j++) {
String str = String.valueOf(arr_I[j]);
if (str.contains(part)) {
indexs[i][flag] = j;
values[i][flag] = arr_I[j];
flag++;
}
}
flags[i] = flag;
}
// 统计要输出的数字个数
int count = 0;
for (int i : flags) {
if (i > 0) {
count += 2; // 需要输出 R<i> 以及在 I 中匹配的个数（两个数）
count += i * 2;// 需要输出I中匹配的数的索引及其数值（i*2个数）
}
}
// 输出格式
System.out.print(count);
for (int i = 0; i < arr_R.length; i++) {
if (flags[i] > 0) {
System.out.print(" " + arr_R[i] + " " + flags[i]);
for (int j = 0; j < flags[i]; j++) {
System.out.print(" " + indexs[i][j] + " " + values[i][j]);
}
}
}
}
}
发表于 2024-09-08 10:53:22
回复(0)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Map<Integer,List<int[]>> sequence2 = new TreeMap<>();
int[] sequence1 = null;
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextInt()) { // 注意 while 处理多个 case
int a = in.nextInt();
sequence1 = new int[a];
for (int i =0;i<a ;i++){
sequence1[i]=in.nextInt();
}
int b = in.nextInt();
for (int i =0;i<b ;i++){
sequence2.put(in.nextInt(),new ArrayList<>());
}
}
for(int i = 0 ; i< sequence1.length ; i ++){
final String sequence = sequence1[i]+"" ;
final int i1= i ;
sequence2.forEach((key,value) ->{
if(sequence.contains(key + "")){
value.add(new int[]{i1,Integer.parseInt(sequence)});
}
});
};
List<Integer> sq = new ArrayList<>() ;
sequence2.forEach((key,value) ->{
if(value.size() > 0){
sq.add(key);
sq.add(value.size());
value.forEach(s -> {
sq.add(s[0]);
sq.add(s[1]);
});
}
});
System.out.printf(sq.size() +" ");
sq.forEach(ss ->System.out.print(ss +" "));
}
}
发表于 2024-09-06 14:28:28
回复(0)
Java 已AC（考虑不是很周全，空间复杂度较高，且存在多余循环）
优化思路：不依赖HashMap存储，先sort(rNums)，使用StringBuffer记录每次匹配结果和匹配数量，最后输出答案。
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 相同的R<i>只输出索引小的
// R<i>从小到大排序
// 输出格式 总数 R<i> R<i>匹配数 l索引 l值
while (in.hasNextInt()) {
String[] iArr = in.nextLine().split(" "); // 忽视index=0
String[] rArr = in.nextLine().split(" "); // r不需考虑坐标
if(rArr[0].equals("0") || iArr[0].equals("0")){
System.out.println("0");
continue;
}
// r数组转换为Integer
int[] rNums = new int[rArr.length-1];
for(int i=0; i<rNums.length; i++){
rNums[i] = Integer.parseInt(rArr[i+1]);
}
// I包含R用字符串匹配实现
// List<int[]> 存储I中匹配成功的串
Map<Integer,List<int[]>> map = new HashMap<>();
List<Integer> ans = new ArrayList<>(); // 存储答案key值
int count = 0; // 记录输出数据量
for(int i=0; i<rNums.length; i++){
if(!map.containsKey(rNums[i])){
List<int[]> rNumAns = match(iArr,""+rNums[i]); // 匹配
if(!rNumAns.isEmpty()){
ans.add(rNums[i]);
map.put(rNums[i],rNumAns);
count += (rNumAns.size()*2 + 2);
}
}
}
// 输出数据
StringBuffer s = new StringBuffer();
s.append(count);
Collections.sort(ans); // 排序答案Key值
List<int[]> temp = new ArrayList<>();
for(int num:ans){
temp = map.get(num);
s.append(" " + num + " " + temp.size());
for(int[] tempSet:temp)
s.append(" "+tempSet[0]+" "+tempSet[1]); // 依次输出坐标和值
}
System.out.println(s.toString());
}
}
public static List<int[]> match(String[] iArr, String rNum){
List<int[]> rNumAns = new ArrayList<>();
for(int i=1; i<iArr.length; i++){
if(iArr[i].matches("(.*)"+rNum+"(.*)")){
int[] temp = new int[2];
temp[0] = i-1;
temp[1] = Integer.parseInt(iArr[i]);
rNumAns.add(temp);
}
}
return rNumAns;
}
}
发表于 2024-08-28 16:46:01
回复(0)
import java.util.*;
import java.util.stream.Collectors;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
static List<Integer> l = new ArrayList();
static List<Integer> r = new ArrayList();
static List<Integer> ans = new ArrayList();
static class Item {
int dx;
int val;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextInt()) { // 注意 while 处理多个 case
int n = in.nextInt();
for (int i = 0; i < n; ++ i) l.add(in.nextInt());
n = in.nextInt();
for (int i = 0; i < n; ++ i) r.add(in.nextInt());
r = r.stream().distinct().sorted().collect(Collectors.toList());
for (int a : r) {
List<Item> t = new ArrayList();
for (int i = 0; i < l.size(); ++ i) {
String str = l.get(i) + "";
if (str.contains(a + "")) {
Item it = new Item();
it.dx = i; it.val = l.get(i);
t.add(it);
}
}
if (t.size() > 0) {
ans.add(a);
ans.add(t.size());
for (Item it : t) {
ans.add(it.dx);
ans.add(it.val);
}
}
}
System.out.print(ans.size() + " ");
for (int a : ans) System.out.print(a + " ");
}
}
}
编辑于 2024-03-24 13:59:29
回复(0)
难度其实不大，关键要读懂题意，选择合适的数据结构
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//处理第一行
int n = in.nextInt();
String[] str = in.nextLine().split(" ");
//处理第二行
int m = in.nextInt();
Set<Integer> set = new TreeSet<>();//排序+去重
for (int j = 0; j < m; j++) {
set.add(in.nextInt());
}
//寻找符合各个要求的元素
List<List<String>> list = new ArrayList<>();
for (int i : set) {
List<String> temp = new ArrayList<>();
for (int k = 1; k < n + 1; k++) {
if (str[k].contains(Integer.toString(i))) {
temp.add(Integer.toString(k - 1) + " " + str[k]);
}
}
list.add(temp);
}
//计算待输出的元素个数
int total = 0;
for (int i = 0; i < list.size(); i++) {
int size=list.get(i).size();
total += 2 * size;
if (size != 0) {
total += 2;//如果没有满足条件的就不+2
}
}
//按格式输出元素
List<Integer> nums=new ArrayList<>(set);
System.out.print(total);
for (int i = 0; i < list.size(); i++) {
int size=list.get(i).size();
if (size != 0) {
System.out.print(" "+nums.get(i)+" "+size);
}
for(int j=0;j<size;j++){
System.out.print(" "+list.get(i).get(j));
}
}
}
}
编辑于 2024-03-22 14:49:57
回复(0)
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int ni = in.nextInt();
int[] nis = new int[ni];
for (int i = 0; i < ni; i++) {
nis[i] = in.nextInt();
}
int nr = in.nextInt();
int[] nrs = new int[nr];
for (int i = 0; i < nr; i++) {
nrs[i] = in.nextInt();
}
List<Integer> res = new ArrayList<>();
Arrays.sort(nrs);
nrs = Arrays.stream(nrs).distinct().toArray();
for (int i = 0; i < nrs.length; i++) {
int sum = 0;
List<Integer> res2 = new ArrayList<>();
for (int j = 0; j < nis.length; j++) {
if (String.valueOf(nis[j]).contains(String.valueOf(nrs[i]))) {
res2.add(j);
res2.add(nis[j]);
sum++;
}
}
if (sum != 0) {
res.add(nrs[i]);
res.add(sum);
res.addAll(res2);
}
}
System.out.print(res.size() + " ");
res.forEach(i->System.out.print(i + " "));
}
}
编辑于 2024-01-20 16:16:43
回复(0)
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNext()) { // 注意 while 处理多个 case
//储存R
int rnum = in.nextInt();
ArrayList<String> rarr = new ArrayList<>();
for (int i = 0; i < rnum; i++) {
rarr.add(in.nextInt() + "");
}
//储存I
int inum = in.nextInt();
TreeSet<Integer> treeSet = new TreeSet<>();//去重且排序
for (int i = 0; i < inum; i++) {
treeSet.add(in.nextInt());
}
int count = 0;//记录每个I在R中的次数
String res = "";//记录I出现在R中的索引+R值 形如:0 123 3 453 7 3 9 453456 13 453 14 123
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
int num = 0;//num记录res 中非空格的数量
for (Integer i : treeSet) {
String stringI = i.toString();
for (int j = 0; j < rarr.size(); j++) {
if (rarr.get(j).contains(stringI)) {
count++;
res += "".equals(res) ? j + " " + rarr.get(j) : " " + j + " " + rarr.get(j);
}
}
res = stringI + " " + count + " " + res;//这里拼接上对应的I值与R中出现次数 形如:3 6 0 123 3 453 7 3 9 453456 13 453 14 123
if (count == 0) {
res = "";//count为0时 要重置res
continue;
}
linkedHashSet.add(res);
num += count * 2;
count = 0;
res = "";
}
num = num + linkedHashSet.size() * 2;
String out = "";
for (String s : linkedHashSet) {
out += s+" ";
}
System.out.println(num + " " + out);
}
}
}
发表于 2023-12-12 15:51:58
回复(0)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 得到序列I的数量
int iNum;
if (in.hasNextInt()) {
iNum = in.nextInt();
} else {
return;
}
if (iNum <= 0) {
return;
}
// 得到序列I的内容
Map<Integer, Integer> iMap = new HashMap<>();
for (int i = 0; i < iNum; i++) {
if (in.hasNextInt()) {
iMap.put(i, in.nextInt());
} else {
return;
}
}
// 得到序列R的数量
int rNum;
if (in.hasNextInt()) {
rNum = in.nextInt();
} else {
return;
}
if (rNum <= 0) {
return;
}
// 得到序列R的内容
TreeSet<Integer> rSet = new TreeSet<>();
for (int i = 0; i < rNum; i++) {
if (in.hasNextInt()) {
rSet.add(in.nextInt());
} else {
return;
}
}
StringBuilder allSb = new StringBuilder();
// 计算序列I中满足包含R内容的部分
for (Integer r : rSet) {
String rStr = String.valueOf(r);
int count = 0;
StringBuilder rSb = new StringBuilder();
for (Map.Entry<Integer, Integer> entry : iMap.entrySet()) {
if (String.valueOf(entry.getValue()).contains(rStr)) {
count++;
rSb.append(entry.getKey())
.append(" ")
.append(entry.getValue())
.append(" ");
}
}
if (count > 0) {
rSb.insert(0, r + " " + count + " ");
allSb.append(rSb.toString());
}
}
// 计算总数量
String all = allSb.toString();
int count = all.split(" ").length;
// 输出
System.out.println(count + " " + all);
}
}
发表于 2023-11-10 12:11:30
回复(0)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
//记录输入
int I_num = in.nextInt();
Integer[] I=new Integer[I_num];
List<Integer> list=new ArrayList<Integer>();
for (int i = 0; i < I_num; i++) {
I[i]=in.nextInt();
}
int R_num = in.nextInt();
Integer[] R=new Integer[R_num];
TreeSet<Integer> treeSet=new TreeSet<>();
for (int i = 0; i < R_num; i++) {
R[i]=in.nextInt();
treeSet.add(R[i]);
}
//记录总输出个数，每一个R对应的I个数
int[] R_I_num=new int[treeSet.size()];
int num=0;
int count=0;
for (Integer integer : treeSet) {
for (int i = 0; i < I_num; i++) {
list.clear();
if(I[i].toString().contains(integer.toString())&&list.contains(I[i])!=true)
{
R_I_num[count]+=1;
num+=2;
list.add(I[i]);
}
}
if(R_I_num[count]!=0)
{
num+=2;
}
count++;
}
//打印
System.out.print(num);
count=0;
for (Integer integer : treeSet) {
if (R_I_num[count]!=0){
System.out.print(" "+integer+" "+R_I_num[count]);
for (int i = 0; i < I_num; i++) {
list.clear();
if(I[i].toString().contains(integer.toString())&&list.contains(I[i])!=true)
{
System.out.print(" "+i+" "+I[i]);
list.add(I[i]);
}
}
}
count++;
}
}
}
}
发表于 2023-09-07 14:37:41
回复(0)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextInt()) { // 注意 while 处理多个 case
int inum = in.nextInt();
int[] iarray = new int[inum];
for(int i = 0; i < inum; i++){
iarray[i] = in.nextInt();
}
int rnum = in.nextInt();
int[] rarray = new int[rnum];
for(int i = 0; i < rnum; i++){
rarray[i] = in.nextInt();
}
function(iarray, rarray);
}
}
public static void function(int[] iarray, int[] rarray){
Map<Integer, Map<Integer, Integer>> map = new TreeMap<>();
Arrays.sort(rarray);
TreeSet<Integer> rset = new TreeSet<>((o1, o2) -> o1.compareTo(o2));
for(int i = 0; i < rarray.length; i++){
rset.add(rarray[i]);
}
int n = iarray.length;
int count = 0;
for(int num : rset){
Map<Integer, Integer> submap = new TreeMap<>();
for(int i = 0; i < n; i++){
if(isMatch(num, iarray[i])){
submap.put(i, iarray[i]);
count++;
}
}
if(!submap.isEmpty()){
map.put(num, submap);
}
}
System.out.print((count * 2 + map.size() * 2)+ " ");
for(Integer it : map.keySet()){
System.out.print(it + " " + map.get(it).size() + " ");
map.get(it).forEach((key, value) ->{
System.out.print(key + " " + value + " ");
});
}
}
public static boolean isMatch(int num, int num2){
String s1 = num + "";
String s2 = num2 + "";
return s2.contains(s1) ? true : false;
}
}
// 数据结构算是被用明白了
发表于 2023-08-19 17:03:48
回复(0)
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextInt()) { // 注意 while 处理多个 case
int a = in.nextInt();
int [] i=new int[a];
for(int k=0;k<a;k++){
i[k]=in.nextInt();
}
int b = in.nextInt();
HashSet<Integer> set=new HashSet();
for(int k=0;k<b;k++){
set.add(in.nextInt());
}
List<Integer> list=new ArrayList(set);
Collections.sort(list);
HashMap<Integer,List<Integer>> map=new HashMap();
for(int k:list){
List<Integer> indexes=new ArrayList();
for(int j=0;j<a;j++){
boolean contain= String.valueOf(i[j]).contains(k+"");
if(contain){
indexes.add(j);
}
}
map.put(k,indexes);
}
List<Integer> result=new ArrayList();
for(int k:list){
List<Integer> data=map.get(k);
if(data.size()>0){
result.add(k);
result.add(data.size());
for(int m=0;m<data.size();m++){
int index=data.get(m);
result.add(index);
result.add(i[index]);
}
}
}
System.out.print(result.size());
for(int n:result){
System.out.print(" "+n);
}
}
}
}
发表于 2023-08-07 23:16:17
回复(0)
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
// I 15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123
// R 5 6 3 6 3 0
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String iLIne = in.nextLine();
String rLIne = in.nextLine();
String[] iArr = iLIne.split(" ");
String[] rArr = rLIne.split(" ");
// 存放 R<i>
Map<Integer, Integer> Ri = new LinkedHashMap<>();
// 存放 R<i> 和 索引 <==> I
Map<Integer, LinkedHashMap<Integer, Integer>> index = new LinkedHashMap<>();
// 存放 R<i> 和 索引的顺序
Map<Integer, List<Integer>> sx = new HashMap<>();
String R = "";
String I = "";
for (int i = 1; i <= Integer.parseInt(rArr[0]); i++) {
R = rArr[i];
for (int j = 1; j <= Integer.parseInt(iArr[0]); j++) {
I = iArr[j];
if (I.contains(R)) {
Integer key = Integer.valueOf(R);
LinkedHashMap<Integer, Integer> map = index.get(key);
if (map == null) {
Ri.put(key, Ri.getOrDefault(key, 0) + 1);
map = new LinkedHashMap<>();
map.put(j - 1, Integer.valueOf(I));
index.put(key, map);
List<Integer> sxList = new ArrayList<>();
sxList.add(j - 1);
sx.put(key, sxList);
} else {
if (map.get(j - 1) == null) {
Ri.put(key, Ri.getOrDefault(key, 0) + 1);
map.put(j - 1, Integer.valueOf(I));
index.put(key, map);
List<Integer> sxList = sx.get(key);
sxList.add(j - 1);
sx.put(key, sxList);
}
}
}
}
}
List<Integer> list = new ArrayList<>();
List<Integer> ketSet = new ArrayList<>(Ri.keySet());
ketSet.sort((a, b) -> a.compareTo(b));
for (Integer key : ketSet) {
list.add(key);
LinkedHashMap<Integer, Integer> map = index.get(key);
List<Integer> sxList = sx.get(key);
list.add(Ri.get(key));
sxList.forEach(index1 -> {
list.add(index1);
list.add(map.get(index1));
});
}
StringBuilder builder = new StringBuilder();
builder.append(list.size());
for (int i=0; i<list.size(); i++) {
builder.append(" ").append(list.get(i));
}
System.out.print(builder.toString());
// 这个会导致格式不对
// String result = list.toString().replace("[", "").replace("]", "").replace(",", " ");
// System.out.print(list.size() + " " + result);
}
}
发表于 2023-07-14 19:18:47
回复(1)
import java.util.Scanner;
import java.util.TreeSet;
import java.util.ArrayList;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextInt()) { // 注意 while 处理多个 case
int ILength = in.nextInt();
int[] IArr = new int[ILength];
for (int i = 0; i < ILength; i++) {
IArr[i] = in.nextInt();
}
int RLength = in.nextInt();
int[] RArr = new int[RLength];
for (int i = 0; i < RLength; i++) {
RArr[i] = in.nextInt();
}
int[] newRArr = getRArr(RArr);
ArrayList<String> output = new ArrayList<String>();
output = getResult(IArr, newRArr);
for (int i = 0; i < output.size(); i++) {
if (i < output.size() - 1) {
System.out.print(output.get(i));
System.out.print(" ");
} else {
System.out.print(output.get(i));
}
}
}
}
//返回去重排序的R序列
public static int[] getRArr(int[] input) {
int length = input.length;
TreeSet<Integer> TS = new TreeSet<Integer>();
for (int i = 0; i < length; i++) {
TS.add(Integer.valueOf(input[i]));
}
int size = TS.size();
int[] result = new int[size];
int n = 0;
for (Integer i : TS) {
result[n] = i.intValue();
n++;
}
return result;
}
//输入IArr和去重排序后的RArr，返回目标ArrayList
public static ArrayList<String> getResult(int[] I, int[] R) {
ArrayList<String> result = new ArrayList<String>();
int Ilength = I.length;
int Rlength = R.length;
for (int i = 0; i < Rlength; i++) {
int count = 0;
String Rnum = String.valueOf(R[i]);
for (int j = 0; j < Ilength; j++) {
String Inum = String.valueOf(I[j]);
if (Inum.contains(Rnum)) {
if (count == 0) {
result.add(Rnum);
}
count++;
result.add(String.valueOf(j));
result.add(Inum);
}
}
if (count != 0) {
result.add(result.size() - count * 2,
String.valueOf(count)); //插入符合个数
}
}
result.add(0, String.valueOf(result.size()));
return result;
}
}
发表于 2023-07-03 20:58:47
回复(0)
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
StringBuilder print = new StringBuilder();
while (in.hasNext()) {
int len = in.nextInt();
List<Integer> i = new ArrayList<>();
for (int j = 0; j < len; j++) {
i.add(in.nextInt());
}
len = in.nextInt();
TreeSet<Integer> r = new TreeSet<>();
for (int j = 0; j < len; j++) {
r.add(in.nextInt());
}
for(int v : r){
int count = 0;
StringBuilder ap = new StringBuilder();
for (int j = 0; j < i.size(); j++) {
if(String.valueOf(i.get(j)).contains(v + "")){
count++;
ap.append(j).append(" ").append(i.get(j)).append(" ");
}
}
if(count > 0){
print.append(v).append(" ").append(count).append(" ")
.append(ap);
}
}
}
print = print.deleteCharAt(print.length() - 1);
int size = print.toString().split(" ").length;
System.out.println(size + " " + print);
}
}
发表于 2023-04-25 11:29:03
回复(0)
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String I = scanner.nextLine();
String[] splitI = I.split(" ");
int INum = Integer.parseInt(splitI[0]);
ArrayList<String> IarrayList = new ArrayList<>();
for (int i = 1; i <= INum; i++) {
IarrayList.add(splitI[i]);
}
int RNum = scanner.nextInt();
HashSet<Integer> Rset = new HashSet<>();
for (int i = 0; i < RNum; i++) {
Rset.add(scanner.nextInt());
}
// Collections.sort(set);Hashset排序的四种方法
// 1.放到ArrayList中，利用ArrayList.sort来排序
// 2.放到TreeSet中，会自动升序排序。也可以类似于array.sort中的new Comparator<String>()
// 来对TreeSet排序
TreeSet<Integer> set = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
set.addAll(Rset);
HashMap<Integer, List<Integer>> map = new HashMap<>();
int countNum = 0;
for (int i : set) {
ArrayList<Integer> IndexArr = new ArrayList<>();
String s = String.valueOf(i);
for (int j = 0; j < IarrayList.size(); j++) {
// StringBuilder stringBuilder = new StringBuilder();
// StringBuilder append = stringBuilder.append(arrayList.get(j));
// append.re
String s1 = IarrayList.get(j);
// String replaceAll = s1.replaceAll(s, "");
if (s1.contains(s)) {
IndexArr.add(j);
map.put(i, IndexArr);
countNum++;
}
}
}
ArrayList<Integer> resArr = new ArrayList<>();
for (int i : set) {
if (map.get(i) != null) {
resArr.add(i);
resArr.add(map.get(i).size());
for (int j = 0; j < map.get(i).size(); j++) {
List<Integer> integers = map.get(j);
resArr.add(map.get(i).get(j));
resArr.add(Integer.parseInt(IarrayList.get( map.get(i).get(j))));
}
}
}
System.out.print(resArr.size() + " ");
for (int i = 0; i < resArr.size(); i++) {
System.out.print(resArr.get(i) + " ");
}
}
}
发表于 2023-04-24 21:52:14
回复(0)
问题信息
难度：
75条回答
2190收藏
39009浏览
通过挑战的用户
查看代码-
2022-11-09 10:09:57
-
2022-10-01 08:01:08
-
2022-09-18 14:38:38
-
2022-09-17 01:48:34
-
2022-09-16 11:17:54
相关试题
-
扫描二维码，关注牛客网
- 意见反馈
-
下载牛客APP，随时随地刷题
扫一扫，把题目装进口袋
- 求职之前，先上牛客
-
扫描二维码，进入QQ群
扫描二维码，关注牛客公众号
- 公司地址：北京市朝阳区北苑路北美国际商务中心K1座一层-北京牛客科技有限公司
- 联系方式：010-60728802 投诉举报电话：010-57596212（朝阳人力社保局）
- 牛客科技© All rights reserved admin@nowcoder.com
- 京ICP备14055008号-4 增值电信业务经营许可证 营业执照 人力资源服务许可证
-
京公网安备
11010502036488号
