力扣11~20

11.

比赛中的配对次数

难度简单101

给你一个整数 n ，表示比赛中的队伍数。比赛遵循一种独特的赛制：

• 如果当前队伍数是 偶数 ，那么每支队伍都会与另一支队伍配对。总共进行 n / 2 场比赛，且产生 n / 2 支队伍进入下一轮。
• 如果当前队伍数为 奇数 ，那么将会随机轮空并晋级一支队伍，其余的队伍配对。总共进行 (n - 1) / 2 场比赛，且产生 (n - 1) / 2 + 1 支队伍进入下一轮。

返回在比赛中进行的配对次数，直到决出获胜队伍为止。

class Solution {
    public int numberOfMatches(int n) {
        return n - 1;
    }
}

class Solution(object):
    def numberOfMatches(self, n):
        return n - 1

12

找到一个数字的 K 美丽值

难度简单8

一个整数 num 的 k 美丽值定义为 num 中符合以下条件的 子字符串 数目：

• 子字符串长度为 k 。
• 子字符串能整除 num 。

给你整数 num 和 k ，请你返回 num 的 k 美丽值。

注意：

• 允许有 前缀 0 。
• 0 不能整除任何值。

一个 子字符串 是一个字符串里的连续一段字符序列。

class Solution:
    def divisorSubstrings(self, num: int, k: int) -> int:
        s = str(num)   # num 十进制表示字符串
        n = len(s)
        res = 0
        for i in range(n - k + 1):
            # 枚举所有长度为 k 的子串
            tmp = int(s[i:i+k])
            if tmp != 0 and num % tmp == 0:
                res += 1
        return res

13.

两个数对之间的最大乘积差

难度简单21

两个数对 (a, b) 和 (c, d) 之间的 乘积差 定义为 (a * b) - (c * d)。

• 例如，(5, 6) 和 (2, 7) 之间的乘积差是 (5 * 6) - (2 * 7) = 16 。

给你一个整数数组 nums ，选出四个 不同的 下标 w、x、y 和 z ，使数对 (nums[w], nums[x]) 和 (nums[y], nums[z]) 之间的 乘积差 取到 最大值 。

返回以这种方式取得的乘积差中的 最大值 。

int cmp(const int* a, const int* b){
    if (*a > *b)return -1;
    else if (*a < * b)return 1;
    return 0;
}

int maxProductDifference(int* nums, int numsSize){
    int i;

    qsort(nums, numsSize, sizeof(int), (int(*)(const void*, const void*))cmp);

    return nums[0]*nums[1] - nums[numsSize-1]*nums[numsSize-2];
}

14

字符串中的最大奇数

难度简单23

给你一个字符串 num ，表示一个大整数。请你在字符串 num 的所有 非空子字符串 中找出 值最大的奇数 ，并以字符串形式返回。如果不存在奇数，则返回一个空字符串 "" 。

子字符串 是字符串中的一个连续的字符序列。

class Solution {
    public String largestOddNumber(String num) {
        int index=-1;
        for (int i = 0; i <num.length(); i++) {
            if((num.charAt(i)-'0')%2!=0){
                index=i;
            }
        }
        return num.substring(0,index+1);
    }
}

15.

数组异或操作

难度简单111

给你两个整数，n 和 start 。

数组 nums 定义为：nums[i] = start + 2*i（下标从 0 开始）且 n == nums.length 。

请返回 nums 中所有元素按位异或（XOR）后得到的结果。

class Solution {
    public int xorOperation(int n, int start) {
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans ^= (start + i * 2);
        }
        return ans;
    }
}

class Solution:
    def xorOperation(self, n: int, start: int) -> int:
        ans = 0
        for i in range(n):
            ans ^= (start + i * 2)
        return ans

int xorOperation(int n, int start) {
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans ^= (start + i * 2);
    }
    return ans;
}

16

最富有客户的资产总量

难度简单123

给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i​​​​​位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量。

客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。

class Solution {
    public int maximumWealth(int[][] accounts) {
        int m = accounts.length, n = accounts[0].length, ans = 0;
        for (int i = 0; i < m; i++) {
            int cur = 0;
            for (int j = 0; j < n; j++) cur += accounts[i][j];
            ans = Math.max(ans, cur);
        }
        return ans;
    }
}

17

统计各位数字之和为偶数的整数个数

难度简单9

给你一个正整数 num ，请你统计并返回 小于或等于 num 且各位数字之和为 偶数 的正整数的数目。

正整数的 各位数字之和 是其所有位上的对应数字相加的结果。

class Solution {
    public int countEven(int num) {
        int count =0;
        for(int i=1;i<=num;i++){
            if(check(i)){
                count++;
            }
        }
        return count;
    }
    public boolean check(int num){
        int res = 0;
        while(num!=0){
            res += num%10;
            num /= 10;
        }
        if(res%2==0){
            return true;
        }
        return false;
    }
}

18.

有序数组的平方

难度简单592

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

 //看的题解，他做得好

   public int[] sortedSquares(int[] nums) {
        // 左指针，指向原数组最左边
        int left = 0;
        // 有指针，指向原数组最右边
        int right = nums.length - 1;
        // 创建一个新数组，存储平方值
        int[] result = new int[nums.length];
        // 得到元素值平方值，从新数组最后位置开始写
        int write = nums.length - 1;
        // 左右指针相遇（逐渐靠拢的过程）之后不再循环
        while (left <= right){
            // 如果原数组的左指针对应的平方值大于右指针，那么往新数组最后位置写入左指针对应的平方值
            if (nums[left] * nums[left] > nums[right] * nums[right]){
                result[write] = nums[left] * nums[left];
                // 左指针右移
                left ++;
                // 移动新数组待写入的位置
                write --;
            }
            else {
                result[write] = nums[right] * nums[right];
                right --;
                write --;
            }
        }
        return result;
    }

作者：sanshu
链接：https://leetcode.cn/problems/squares-of-a-sorted-array/solution/shuang-zhi-zhen-by-du-tu-9-gxo5/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。