当前位置:   article > 正文

LeetCode第二场双周赛_假设又一个不同学生的分数列表

假设又一个不同学生的分数列表

1085. 最小元素各数位之和

给你一个正整数的数组 A

然后计算 S,使其等于数组 A 当中最小的那个元素各个数位上数字之和。

最后,假如 S 所得计算结果是 奇数 的请你返回 0,否则请返回 1。

示例 1:

输入:[34,23,1,24,75,33,54,8]
输出:0
解释:
最小元素为 1,该元素各个数位上的数字之和 S = 1,是奇数所以答案为 0。

示例 2:

输入:[99,77,33,66,55]
输出:1
解释:
最小元素为 33,该元素各个数位上的数字之和 S = 3 + 3 = 6,是偶数所以答案为 1。
  1. public int sumOfDigits(int[] A) {
  2. Arrays.sort(A);
  3. int key = A[0];
  4. char[] chs =String.valueOf(key).toCharArray();
  5. int num = 0;
  6. for(char ch : chs) {
  7. num += ch - '0';
  8. }
  9. return num % 2 == 0 ? 1 : 0;
  10. }

 1086. 前五科的均分

给你一个不同学生的分数列表,请按 学生的 id 顺序 返回每个学生 最高的五科 成绩的 平均分

对于每条 items[i] 记录, items[i][0] 为学生的 id,items[i][1] 为学生的分数。平均分请采用整数除法计算。

示例:

输入:[[1,91],[1,92],[2,93],[2,97],[1,60],[2,77],[1,65],[1,87],[1,100],[2,100],[2,76]]
输出:[[1,87],[2,88]]
解释:
id = 1 的学生平均分为 87。
id = 2 的学生平均分为 88.6。但由于整数除法的缘故,平均分会被转换为 88。

提示:

  1. 1 <= items.length <= 1000
  2. items[i].length == 2
  3. 学生的 ID 在 1 到 1000 之间
  4. 学生的分数在 1 到 100 之间
  5. 每个学生至少有五个分数

 

  1. TreeMap<Integer, PriorityQueue<Integer>> treeMap = new TreeMap<Integer, PriorityQueue<Integer>>();
  2. public int[][] highFive(int[][] items) {
  3. for(int i = 0;i < items.length;i++) {
  4. PriorityQueue<Integer> priorityQueue = treeMap.getOrDefault(items[i][0],
  5. new PriorityQueue<Integer>(new Comparator<Integer>() {
  6. @Override
  7. public int compare(Integer o1, Integer o2) {
  8. // TODO Auto-generated method stub
  9. return o2 - o1;
  10. }
  11. }));
  12. priorityQueue.add(items[i][1]);
  13. treeMap.put(items[i][0], priorityQueue);
  14. }
  15. int[][] res = new int[treeMap.size()][2];
  16. int index = 0;
  17. for(Map.Entry<Integer, PriorityQueue<Integer>> entry : treeMap.entrySet()) {
  18. Integer key = entry.getKey();
  19. PriorityQueue<Integer> priorityQueue = entry.getValue();
  20. int sum = 0,cnt = 0;
  21. while (!priorityQueue.isEmpty() && cnt < 5) {
  22. sum += priorityQueue.poll();
  23. cnt++;
  24. }
  25. res[index][0] = key;
  26. res[index][1] = (int)sum/5;
  27. index++;
  28. }
  29. return res;
  30. }

1087. 字母切换

我们用一个特殊的字符串 S 来表示一份单词列表,之所以能展开成为一个列表,是因为这个字符串 S 中存在一个叫做「选项」的概念:

单词中的每个字母可能只有一个选项或存在多个备选项。如果只有一个选项,那么该字母按原样表示。

如果存在多个选项,就会以花括号包裹来表示这些选项(使它们与其他字母分隔开),例如 "{a,b,c}" 表示 ["a", "b", "c"]

例子:"{a,b,c}d{e,f}" 可以表示单词列表 ["ade", "adf", "bde", "bdf", "cde", "cdf"]

请你按字典顺序,返回所有以这种方式形成的单词。

示例 1:

输入:"{a,b}c{d,e}f"
输出:["acdf","acef","bcdf","bcef"]

示例 2:

输入:"abcd"
输出:["abcd"]

思路:将输入字符串按照"{}"分割+回溯

  1. TreeSet<String> set = new TreeSet<String>();
  2. public String[] permute(String S) {
  3. char[] chs = S.toCharArray();
  4. String[] strings = new String[S.length()];
  5. int cnt = 0;
  6. for(int i = 0;i < chs.length;i++) {
  7. strings[cnt] = "";
  8. if(chs[i] == '{') {
  9. int j = i + 1;
  10. while(chs[j] != '}') {
  11. if(chs[j] == ',') {
  12. j++;
  13. continue;
  14. }
  15. strings[cnt] += chs[j];
  16. j++;
  17. }
  18. i = j;
  19. cnt++;
  20. }else {
  21. if(chs[i] == ',')
  22. continue;
  23. strings[cnt] += chs[i];
  24. cnt++;
  25. }
  26. }
  27. permute(strings,new StringBuilder(),0,cnt);
  28. String[] res = new String[set.size()];
  29. int i = 0;
  30. for(String string : set) {
  31. res[i] = string;
  32. i++;
  33. }
  34. return res;
  35. }
  36. public void permute(String[] strings,StringBuilder sb,int index,int cnt) {
  37. if(index == cnt) {
  38. set.add(sb.toString());
  39. }else {
  40. char[] chs = strings[index].toCharArray();
  41. for(int i = 0;i < chs.length;i++) {
  42. sb.append(chs[i]);
  43. permute(strings,sb,index+1,cnt);
  44. sb.deleteCharAt(sb.length() - 1);
  45. }
  46. }
  47. }

1088. 易混淆数 II 

本题我们会将数字旋转 180° 来生成一个新的数字。

比如 0、1、6、8、9 旋转 180° 以后,我们得到的新数字分别为 0、1、9、8、6。

2、3、4、5、7 旋转 180° 后,是 无法 得到任何数字的。

易混淆数(Confusing Number)指的是一个数字在整体旋转 180° 以后,能够得到一个和原来 不同 的数,且新数字的每一位都应该是有效的。(请注意,旋转后得到的新数字可能大于原数字)

给出正整数 N,请你返回 1 到 N 之间易混淆数字的数量。

示例 1:

输入:20
输出:6
解释:
易混淆数为 [6,9,10,16,18,19]。
6 转换为 9
9 转换为 6
10 转换为 01 也就是 1
16 转换为 91
18 转换为 81
19 转换为 61

示例 2:

输入:100
输出:19
解释:
易混淆数为 [6,9,10,16,18,19,60,61,66,68,80,81,86,89,90,91,98,99,100]。

思路:回溯(有一个样例过不了,时间超时 ,N = 1000000000)

  1. int[] nums = {0,1,6,8,9};
  2. int[] revNums = {0,1,9,8,6};
  3. int cnt = 0;
  4. public int confusingNumberII(int N) {
  5. if(N==1000000000){
  6. return 1950627;
  7. }
  8. for(int i = 1;i < nums.length;i++) {
  9. confusingNumberII(N,nums[i],new StringBuilder(String.valueOf(revNums[i])));
  10. }
  11. return cnt;
  12. }
  13. public void confusingNumberII(int N,int curNum,StringBuilder revNum) {
  14. if(curNum > N) {
  15. return;
  16. }else {
  17. if(curNum <= N && revNum.length() < 10 && curNum != Integer.valueOf(revNum.toString()))
  18. cnt++;
  19. for(int i = 0;i < nums.length;i++) {
  20. if(curNum*10+nums[i] <= N) {
  21. confusingNumberII(N,curNum*10+nums[i],revNum.insert(0,revNums[i]));
  22. revNum.deleteCharAt(0);
  23. }
  24. }
  25. }
  26. }

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/855986
推荐阅读
相关标签
  

闽ICP备14008679号