LeetCode学习-第三十九天

第三十九天

我使用的C++，错误的地方请见谅，文章初衷仅用来督促本人学习，如果恰巧能够给你带来帮助，我会十分开心。

一、1006. 笨阶乘

通常，正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。

相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。

例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而，这些运算仍然使用通常的算术运算顺序：我们在任何加、减步骤之前执行所有的乘法和除法步骤，并且按从左到右处理乘法和除法步骤。

另外，我们使用的除法是地板除法（floor division），所以 10 * 9 / 8 等于 11。这保证结果是一个整数。

实现上面定义的笨函数：给定一个整数 N，它返回 N 的笨阶乘。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/clumsy-factorial
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int clumsy(int n) {
    //n个数n次操作，先算乘除后算加减，利用栈来控制顺序
    stack<int> stk;
    stk.push(n);
    n--;
    int index = 0;
    while (n > 0){
        if (index % 4 == 0){
            stk.top() *= n;//第一位为乘
        } else if (index % 4 == 1){
            stk.top() /= n;//第二位为除
        } else if (index % 4 == 2){//加减先入栈再说
            stk.push(n);
        } else{
            stk.push(-n);
        }
        index ++;
        n--;
    }
    int sum = 0;
    while (!stk.empty()){//其余加减数弹出
        sum += stk.top();
        stk.pop();
    }
    return sum;

    }
};

二、2526. 找到数据流中的连续整数

给你一个整数数据流，请你实现一个数据结构，检查数据流中最后 k 个整数是否 等于 给定值 value 。

请你实现 DataStream 类：

DataStream(int value, int k) 用两个整数 value 和 k 初始化一个空的整数数据流。
boolean consec(int num) 将 num 添加到整数数据流。如果后 k 个整数都等于 value ，返回 true ，否则返回 false 。如果少于 k 个整数，条件不满足，所以也返回 false 。

输入：
[“DataStream”, “consec”, “consec”, “consec”, “consec”]
[[4, 3], [4], [4], [4], [3]]
输出：
[null, false, false, true, false]

解释：
DataStream dataStream = new DataStream(4, 3); // value = 4, k = 3
dataStream.consec(4); // 数据流中只有 1 个整数，所以返回 False 。
dataStream.consec(4); // 数据流中只有 2 个整数
// 由于 2 小于 k ，返回 False 。
dataStream.consec(4); // 数据流最后 3 个整数都等于 value， 所以返回 True 。
dataStream.consec(3); // 最后 k 个整数分别是 [4,4,3] 。
// 由于 3 不等于 value ，返回 False 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-consecutive-integers-from-a-data-stream
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class DataStream {
    int n, x, m;
public:
    DataStream(int value, int k) {
        n = k;
        m = value;
        x = 0;

    }
    
    bool consec(int num) {
        if (num == m)
            x++;//如果新加入的num与value相同加一
        else x = 0;//出现不相同的计数置0
        return x >= n;

    }
};

/**
 * Your DataStream object will be instantiated and called as such:
 * DataStream* obj = new DataStream(value, k);
 * bool param_1 = obj->consec(num);
 */
 //摘自leetcode账号：汪乐平 比赛代码
 //仅作学习借鉴使用，如有侵权联系删除

三、2527. 查询数组 Xor 美丽值

给你一个下标从 0 开始的整数数组 nums 。

三个下标 i ，j 和 k 的 有效值 定义为 ((nums[i] | nums[j]) & nums[k]) 。

一个数组的 xor 美丽值 是数组中所有满足 0 <= i, j, k < n 的三元组 (i, j, k) 的 有效值 的异或结果。

请你返回 nums 的 xor 美丽值。

注意：

val1 | val2 是 val1 和 val2 的按位或。
val1 & val2 是 val1 和 val2 的按位与。

输入：nums = [1,4]
输出：5
解释：
三元组和它们对应的有效值如下：

• (0,0,0) 有效值为 ((1 | 1) & 1) = 1
• (0,0,1) 有效值为 ((1 | 1) & 4) = 0
• (0,1,0) 有效值为 ((1 | 4) & 1) = 1
• (0,1,1) 有效值为 ((1 | 4) & 4) = 4
• (1,0,0) 有效值为 ((4 | 1) & 1) = 1
• (1,0,1) 有效值为 ((4 | 1) & 4) = 4
• (1,1,0) 有效值为 ((4 | 4) & 1) = 0
• (1,1,1) 有效值为 ((4 | 4) & 4) = 4
  数组的 xor 美丽值为所有有效值的按位异或 1 ^ 0 ^ 1 ^ 4 ^ 1 ^ 4 ^ 0 ^ 4 = 5 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-xor-beauty-of-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int xorBeauty(vector<int>& nums) {//这题像是一个脑筋急转弯
    //n ^ n = 0而所有三元组中num[i] | nums[j]会出现两次,并且由规则可知，有效值只会出现原数组中的数和0
    /*(0,0,0) 有效值为 ((1 | 1) & 1) = 1
      (0,0,1) 有效值为 ((1 | 1) & 4) = 0  
      (0,1,0) 有效值为 ((1 | 4) & 1) = 1
      在同一个k的情况下，第一行和第三行异或为0，只剩下第二行
      由此最终只剩下0 1 4
      0 ^ n = n*/
        int ans = 0;
        for (int i = 0; i < nums.size(); ++i){
            ans ^= nums[i];
        }
        return ans;
    }
};