牛客网刷题目——20200705

简明题意：

我们定义一个整数可重集合是好的，当且仅当对于集合中任意两个元素 a, b (a≤ba \leq ba≤b) ，所有满足 a≤c≤ba\leq c\leq ba≤c≤b 的元素 c 都在集合中出现过。

现在，给你一个数组 mSet，你需要做的是，对于这个数组的每一个前缀，判断这个前缀是不是一个好的集合。所以，你将计算出的是一个数组，为布尔类型。

输入

[3,5,4,6]

输出

[true,false,true,true]

说明

第一个前缀只有一个元素3，按照好的集合的定义，它显然是连续的。

第二个前缀有一个3和一个5，位于3和5之间的元素4却不在集合中，所以它不是连续的。

第三个前缀添加了一个4，弥补了第二个集合缺少4的问题，所以它是好的。

第四个前缀新增了一个6，依旧连续。

/**
 * Copyright (C), 2018-2020
 * FileName: continuousSet
 * Author:   xjl
 * Date:     2020/7/5 16:44
 * Description: 排序算法
 */
package Sort;

import org.junit.Test;

import java.util.*;

public class continuousSet {
    //通过率64
    public boolean[] continuousSet(int[] mSet) {
        //返回的结果
        boolean[] result = new boolean[mSet.length];
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < mSet.length; i++) {
            //添加元素
            list.add(mSet[i]);
            //选择第一个
            int start = Collections.min(list);
            int end = Collections.max(list);
            int flag = 0;
            //检查是否有序
            while (start <= end) {
                if (!list.contains(start)) {
                    flag = 1;
                    break;
                } else {
                    start++;
                }
            }
            if (flag == 1) {
                result[i] = false;
            } else {
                result[i] = true;
            }
        }
        return result;
    }
    //通过率72%
    public boolean[] continuousSet2(int[] mSet) {
        //返回的结果
        boolean[] result = new boolean[mSet.length];
        TreeSet<Integer> set = new TreeSet<>();
        for (int i = 0; i < mSet.length; i++) {
            //添加元素
            set.add(mSet[i]);
            //选择第一个
            int start = set.first();
            int end = set.last();
            int flag = 0;
            //检查是否有序
            while (start <= end) {
                if (!set.contains(start)) {
                    flag = 1;
                    break;
                } else {
                    start++;
                }
            }
            if (flag == 1) {
                result[i] = false;
            } else {
                result[i] = true;
            }
        }
        return result;
    }
    //通过率100%
    public boolean[] continuousSet3 (int[] mSet) {
        // write code here
        boolean[] res=new boolean[mSet.length];
        if(mSet.length==0) return res;

        Set<Integer> set=new HashSet<>();
        int min=mSet[0];
        int max=mSet[0];
        for(int i=0;i<mSet.length;i++){
            max=Math.max(max,mSet[i]);
            min=Math.min(min,mSet[i]);
            if(set.add(mSet[i])){
                res[i]=(max-min+1==set.size());
            }else{
                res[i]=res[i-1];
            }
        }
        return res;
    }
    @Test
    public void test() {

        int[] array = {2, 1, 0, 4, 1, 0, 3, 4, 0, 2};

        boolean[] booleans = continuousSet2(array);

        for (int i = 0; i < booleans.length; i++) {
            System.out.println(booleans[i]);
        }
    }
}

扔骰子

题意：

牛妹在和牛牛玩扔骰子，他们的游戏规则有所不同；
每个人可以扔nnn次mmm面骰子，来获得nnn个数
得分为任意选取nnn个数中的某些数求和所不能得到的最小的正整数
得分大的人获胜
例如扔骰子333次得到了 1 11 222 55 5，那么这个人的得分是444

牛妹想知道这回合她是否能赢

牛妹的n个数存在数组a中，牛牛的n个数存在数组b中

数组下标从0开始

输入：

n,m与数组a，b

1≤n≤2∗1051 \leq n\leq 2*10^{5} 1≤n≤2∗105

1≤m≤1091 \leq m\leq 10^{9} 1≤m≤109

1≤a[i]≤m1 \leq a[i] \leq m1≤a[i]≤m

1≤b[i]≤m1 \leq b[i] \leq m1≤b[i]≤m

输出：

如果牛妹能在这回合胜利则输出HappyHappyHappy，否则输出SadSadSad

示例1

输入

2,4,[1,2],[1,3]

输出

"Happy"

import java.util.*;

public class Solution {
    /**
     * 
     * @param n int整型 n
     * @param m int整型 m
     * @param a int整型一维数组 a
     * @param b int整型一维数组 b
     * @return string字符串
     */
    public String Throwdice (int n, int m, int[] a, int[] b) {
        // write code here
         Arrays.sort(a);
        Arrays.sort(b);
        long a1 = Num(a, n);
        long b1 = Num(b, n);
        return a1 > b1 ? "Happy" : "Sad";
    }
    
     public long Num(int[] t, int n) {
        long num = 0;
        for (int i = 0; i < n; i++) {
            if (t[i] > num + 1){
                break;
            }
            num += t[i];
        }
        return num;
    }
    
}

在这个特殊的假期里，由于牛牛在家特别无聊，于是他发明了一个小游戏，游戏规则为：将字符串数字中为偶数位的数字进行翻转，将翻转后的结果进行输出。

import java.util.*;


public class Solution {
    /**
     * 
     * @param number string字符串 
     * @return string字符串
     */
    public String change (String number) {
        if(number == null || number.length() == 0 || number.length() > Math.pow(10,7)){
            return number;
        }
        char[] temp = number.toCharArray();
        int left = 0;
        int right = temp.length - 1;

        while(left < right){
            if(temp[left]%2!=0){
                left++;
                continue;
            }
            if(temp[right]%2!=0){
                right--;
                continue;
            }
            
            char tempNum = temp[left];
            temp[left] = temp[right];
            temp[right] = tempNum;
            left++;
            right--;
        }
        return String.valueOf(temp);
    }
}