【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 找出两个整数数组中同时出现的整数

最新推荐文章于 2024-11-01 17:00:11 发布

塔子哥学算法

最新推荐文章于 2024-11-01 17:00:11 发布

阅读量127

点赞数

文章标签：华为od 算法链表数据结构编辑器

本文链接：https://blog.csdn.net/m0_73659489/article/details/131749075

版权

22/23华为最新真题专栏专栏收录该内容

29 篇文章 3 订阅

订阅专栏

为了更好的阅读体检，可以查看我的算法学习网
 本题在线评测链接:P1359

题目描述

现有两个整数数组，需要你找出两个数组中同时出现的整数，并按照如下要求输出:

有同时出现的整数时，先按照同时出现次数(整数在两个数组中都出现并目出现次数较少的那个)进行归类，然后按照出现次数从小到大依次按行输出。
没有同时出现的整数时，输出 $N ULL$ 。

输入描述

第一行为第一个整数数组，第二行为第二个整数数组，每行数中整数与整数之间以英文号分，整数的取值范用为 $[- 200, 200]$ ，数组长度的范用为 $[1 ， 10000]$ 之间的整数。

输出描述

按照出现次数从小到大依次按行输出，每行输出的格式为:

出现次数:该出现次数下的整数升序排序的结果

格式中的”:"为英文冒号，整数间以英文逗号分隔。

样例

输入

5,3,6,-8,0,11
2,8,8,8,-1,15

输出

NULL

说明

两个整数数组没有同时出现的整数，输出 $N ULL$

输入

5,8,11,3,6,8,8,-1,11,2,11,11
11,2,11,8,6,8,8,-1,8,15,3,-9,11

输出

1,-1,2,3,6
3,8,11

说明

两整数数组中同时出现的整数为 $- 12 、 3 、 6 、 8 、 11$ ,其中同时出现次数为 $1$ 的整数为 $- 1, 2, 3, 6$ (升序排序),同时出现次数为 $3$ 的整数为$8,1$1(升序排序),先升序输出出现次数为 $1$ 的整数，再升序输出出现次数为 $3$ 的整数。

思路

题目意思比较直接，我们可以直接按照题目意思模拟。

首先，我们记两个数组分别为 $a rr 1$ 和 $a rr 2$ 。那么我们先找到两个数组中的每一个数字出现的个数，将这些分别存入两个 $ma p$ 里，这里我们记两个 $ma p$ 分别为 $co u n t 1$ 和 $co u n t 2$ ，其中 $k ey$ 是数字， $v a l u e$ 是出现次数。

接着，我们再开辟一个 $ma p$ ，记为 $s am e C o u n tN u m s$ ，其中 $k ey$ 是数字， $v a l u e$ 是出现次数为 $k ey$ 的数的集合。然后，我们就在 $co u n t 1$ 里找每一个关键值是否在 $co u n t 2$ 里出现过，如果出现过，那么我们就取 $min (co u n t 1 [k ey], co u n t 2 [k ey])$ 作为 $v a l u e$ ， $k ey$ 作为 $s am e C o u n tN u m s$ 的 $k ey$ 存入 $s am e C o u n tN u m s$ 中。这样我们就知道每一个出现次数对应的数字有哪些，那么剩下的就是将这个数字进行排序即可。

类似题目推荐

代码

C++

#include <iostream>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <sstream>

using namespace std;

vector<int> arr1;
vector<int> arr2;

string join(const vector<int>& arr, const string& delimiter) {
    string result;
    if (!arr.empty()) {
        result += to_string(arr[0]);
        for (size_t i = 1; i < arr.size(); i++) {
            result += delimiter + to_string(arr[i]);
        }
    }
    return result;
}

void getResult() {
    // 统计arr1中各数字出现次数
    unordered_map<int, int> count1;
    for (int num : arr1) {
        count1[num] = count1[num] + 1;
    }

    // 统计arr2中各数字出现次数
    unordered_map<int, int> count2;
    for (int num : arr2) {
        count2[num] = count2[num] + 1;
    }

    // arr1和arr2是否存在相同的数字，假设不存在，即noSameNum = true
    bool noSameNum = true;

    // 统计arr1和arr2的相同的数字，并记录对于数字出现的次数，注意sameCountNums中次数是键，相同数字是值
    unordered_map<int, vector<int>> sameCountNums;

    for (auto& kv : count1) {
        int num = kv.first;
        int count = kv.second;

        if (count2.find(num) != count2.end()) {
            // 如果数字key在arr1和arr2中都有，则说明存在相同数字，此时noSameNum = false
            noSameNum = false;

            // 整数在两个数组中都出现并且出现次数较少的那个
            int minCount = min(count, count2[num]);

            // sameCountNums中次数是键，相同数字是值
            sameCountNums[minCount].push_back(num);
        }
    }

    // 如果两个数组之间没有相同数字，则输出"NULL"
    if (noSameNum) {
        cout << "NULL" << endl;
        return;
    }

    // 否则，按照相同数字的出现次数升序，来打印对应次数下的相同数字列表
    vector<int> counts;
    for (auto& kv : sameCountNums) {
        counts.push_back(kv.first);
    }
    sort(counts.begin(), counts.end());

    for (int count : counts) {
        // 注意相同数字列表也要升序
        sort(sameCountNums[count].begin(), sameCountNums[count].end());

        cout << count << ":" << join(sameCountNums[count], ",") << endl;
    }
}

int main() {
    string line;
    cin >> line;
    int val = 0;
    int f = 1;
    for(int i = 0; i < line.length(); i++){
        if(line[i] == '-'){
            f = -1;
        }
        else if(line[i] == ','){
            arr1.push_back(val * f);
            val = 0;
            f = 1;
        }else{
            val = val * 10 + line[i] - '0';
        }
    }
    arr1.push_back(val * f);
    val = 0;
    f = 1;
    cin >> line;
    for(int i = 0; i < line.length(); i++){
        if(line[i] == '-'){
            f = -1;
        }
        else if(line[i] == ','){
            arr2.push_back(val * f);
            val = 0;
            f = 1;
        }else{
            val = val * 10 + line[i] - '0';
        }
    }
    arr2.push_back(val * f);
    getResult();

    return 0;
}

python

# 输入获取
arr1 = list(map(int, input().split(",")))
arr2 = list(map(int, input().split(",")))
 
 
# 算法入口
def getResult():
    # 统计arr1中各数字出现次数
    count1 = {}
    for num in arr1:
        count1[num] = count1.get(num, 0) + 1
 
    # 统计arr2中各数字出现次数
    count2 = {}
    for num in arr2:
        count2[num] = count2.get(num, 0) + 1
 
    # arr1和arr2是否存在相同的数字，假设不存在，即noSameNum = true
    noSameNum = True
 
    # 统计arr1和arr2的相同的数字，并记录对于数字出现的次数，注意sameCountKeys中次数是键，相同数字是值
    sameCountNums = {}
 
    for num in count1.keys():
        if num in count2.keys():
            # 如果数字key在arr1和arr2中都有，则说明存在相同数字，此时noSameNum = false
            noSameNum = False
            # 整数在两个数组中都出现并目出现次数较少的那个
            count = min(count1[num], count2[num])
 
            # sameCountKeys中次数是键，相同数字是值
            if sameCountNums.get(count) is None:
                sameCountNums[count] = []
            sameCountNums[count].append(num)
 
    # 如果两个数组之间没有相同数字，则输出"NULL"
    if noSameNum:
        print("NULL")
        return
 
    # 否则，按照相同数字的出现次数升序，来打印对应次数下的相同数字列表
    tmp = list(sameCountNums.keys())
    tmp.sort()
 
    for count in tmp:
        # 注意相同数字列表也要升序
        sameCountNums[count].sort()
        print(f"{count}:{','.join(map(str, sameCountNums[count]))}")
 
 
# 算法调用
getResult()

Java

import java.util.*;
 
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
 
    int[] arr1 = Arrays.stream(sc.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
    int[] arr2 = Arrays.stream(sc.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
 
    getResult(arr1, arr2);
  }
 
  public static void getResult(int[] arr1, int[] arr2) {
    // 统计arr1中各数字出现次数
    HashMap<Integer, Integer> countMap1 = new HashMap<>();
    for (int num : arr1) {
      countMap1.put(num, countMap1.getOrDefault(num, 0) + 1);
    }
 
    // 统计arr2中各数字出现次数
    HashMap<Integer, Integer> countMap2 = new HashMap<>();
    for (int num : arr2) {
      countMap2.put(num, countMap2.getOrDefault(num, 0) + 1);
    }
 
    // arr1和arr2是否存在相同的数字，假设不存在，即noSameNum = true
    boolean noSameNum = true;
 
    // 统计arr1和arr2的相同的数字，并记录对于数字出现的次数，注意sameCountKeys中次数是键，相同数字是值
    HashMap<Integer, TreeSet<Integer>> sameCountKeys = new HashMap<>();
    for (Integer num : countMap1.keySet()) {
      if (countMap2.containsKey(num)) {
        // 如果数字key在arr1和arr2中都有，则说明存在相同数字，此时noSameNum = false
        noSameNum = false;
        // 整数在两个数组中都出现并目出现次数较少的那个
        int count = Math.min(countMap1.get(num), countMap2.get(num));
        // sameCountKeys中次数是键，相同数字是值
        sameCountKeys.putIfAbsent(count, new TreeSet<>());
        sameCountKeys.get(count).add(num);
      }
    }
 
    // 如果两个数组之间没有相同数字，则输出"NULL"
    if (noSameNum) {
      System.out.println("NULL");
      return;
    }
 
    // 否则，按照相同数字的出现次数升序，来打印对应次数下的相同数字列表，注意相同数字列表存入的是TreeSet，因此自然升序
    sameCountKeys.keySet().stream()
        .sorted()
        .forEach(
            count -> {
              StringJoiner sj = new StringJoiner(",", count + ":", "");
              for (Integer num : sameCountKeys.get(count)) {
                sj.add(num + "");
              }
              System.out.println(sj.toString());
            });
  }
}

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
    "sort"
)

var arr1, arr2 []int

func getResult() {
	// 统计arr1中各数字出现次数
	count1 := make(map[int]int)
	for _, num := range arr1 {
		count1[num]++
	}

	// 统计arr2中各数字出现次数
	count2 := make(map[int]int)
	for _, num := range arr2 {
		count2[num]++
	}

	// arr1和arr2是否存在相同的数字，假设不存在，即noSameNum = true
	noSameNum := true

	// 统计arr1和arr2的相同的数字，并记录对于数字出现的次数，注意sameCountNums中次数是键，相同数字是值
	sameCountNums := make(map[int][]int)

	for num := range count1 {
		if _, ok := count2[num]; ok {
			// 如果数字key在arr1和arr2中都有，则说明存在相同数字，此时noSameNum = false
			noSameNum = false

			// 整数在两个数组中都出现并且出现次数较少的那个
			minCount := min(count1[num], count2[num])

			// sameCountNums中次数是键，相同数字是值
			sameCountNums[minCount] = append(sameCountNums[minCount], num)
		}
	}

	// 如果两个数组之间没有相同数字，则输出"NULL"
	if noSameNum {
		fmt.Println("NULL")
		return
	}

	// 否则，按照相同数字的出现次数升序，来打印对应次数下的相同数字列表
	var counts []int
	for count := range sameCountNums {
		counts = append(counts, count)
	}
	sort.Ints(counts)

	for _, count := range counts {
		// 注意相同数字列表也要升序
		sort.Ints(sameCountNums[count])

		fmt.Printf("%d:%s\n", count, join(sameCountNums[count], ","))
	}
}

func main() {
	reader := bufio.NewReader(os.Stdin)

	line, _ := reader.ReadString('\n')
	arr1 = parseIntArray(strings.Split(strings.TrimSpace(line), ","))

	line, _ = reader.ReadString('\n')
	arr2 = parseIntArray(strings.Split(strings.TrimSpace(line), ","))

	getResult()
}

func parseIntArray(arr []string) []int {
	result := make([]int, len(arr))
	for i, str := range arr {
		result[i], _ = strconv.Atoi(str)
	}
	return result
}

func join(arr []int, sep string) string {
	result := make([]string, len(arr))
	for i, num := range arr {
		result[i] = strconv.Itoa(num)
	}
	return strings.Join(result, sep)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

Js

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
 
const lines = [];
rl.on("line", (line) => {
  lines.push(line);
 
  if (lines.length == 2) {
    const arr1 = lines[0].split(",").map(Number);
    const arr2 = lines[1].split(",").map(Number);
    getResult(arr1, arr2);
    lines.length = 0;
  }
});
 
function getResult(arr1, arr2) {
  // 统计arr1中各数字出现次数
  const count1 = new Map();
  for (let num of arr1) {
    count1.set(num, (count1.get(num) ?? 0) + 1);
  }
 
  // 统计arr2中各数字出现次数
  const count2 = new Map();
  for (let num of arr2) {
    count2.set(num, (count2.get(num) ?? 0) + 1);
  }
 
  // arr1和arr2是否存在相同的数字，假设不存在，即noSameNum = true
  let noSameNum = true;
 
  // 统计arr1和arr2的相同的数字，并记录对于数字出现的次数，注意sameCountKeys中次数是键，相同数字是值
  const sameCountNums = new Map();
 
  for (let num of count1.keys()) {
    if (count2.get(num) !== undefined) {
      // 如果数字key在arr1和arr2中都有，则说明存在相同数字，此时noSameNum = false
      noSameNum = false;
      // 整数在两个数组中都出现并目出现次数较少的那个
      const count = Math.min(count1.get(num), count2.get(num));
 
      // sameCountKeys中次数是键，相同数字是值
      sameCountNums.set(count, sameCountNums.get(count) ?? []);
      sameCountNums.get(count).push(num);
    }
  }
 
  // 如果两个数组之间没有相同数字，则输出"NULL"
  if (noSameNum) {
    console.log("NULL");
    return;
  }
 
  // 否则，按照相同数字的出现次数升序，来打印对应次数下的相同数字列表，注意相同数字列表也要进行升序
  [...sameCountNums.keys()]
    .sort((a, b) => a - b)
    .forEach((count) => {
      console.log(
        `${count}:${sameCountNums
          .get(count)
          .sort((a, b) => a - b)
          .join(",")}`
      );
    });
}