python：基础入门练习055 - 060

# -*- coding: utf-8 -*-

# 055: 重新排列数组
# 给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。
# 请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。
# 示例 1：
# 输入：nums = [2,5,1,3,4,7], n = 3
# 输出：[2,3,5,4,1,7]
# 解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]
#
# 示例 2：
# 输入：nums = [1,2,3,4,4,3,2,1], n = 4
# 输出：[1,4,2,3,3,2,4,1]
#
# 示例 3：
# 输入：nums = [1,1,2,2], n = 2
# 输出：[1,2,1,2]

class Solution055:
    def shuffle(self, nums: list[int], n: int) -> list[int]:
        a_len = int(len(nums) / 2)
        a1 = nums[0:a_len]
        a2 = nums[a_len:]
        a3 = []
        for i in range(a_len):
            a3.append(a1[i])
            a3.append(a2[i])
        return a3


s055 = Solution055()
r055 = s055.shuffle([2, 5, 1, 3, 4, 7], 3)
print(r055)  # [2, 3, 5, 4, 1, 7]


# 056: 基于排列构建数组
# 给你一个 从 0 开始的排列 nums（下标也从 0 开始）。请你构建一个 同样长度 的数组 ans ，其中，
# 对于每个 i（0 <= i < nums.length），都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。
# 从 0 开始的排列 nums 是一个由 0 到 nums.length - 1（0 和 nums.length - 1 也包含在内）的不同整数组成的数组。
# 示例 1：
# 输入：nums = [0,2,1,5,3,4]
# 输出：[0,1,2,4,5,3]
# 解释：数组 ans 构建如下：
# ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
#     = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
#     = [0,1,2,4,5,3]
#
# 示例 2：
# 输入：nums = [5,0,1,2,3,4]
# 输出：[4,5,0,1,2,3]
# 解释：数组 ans 构建如下：
# ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
#     = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
#     = [4,5,0,1,2,3]

class Solution056:
    def buildArray(self, nums: list[int]) -> list[int]:
        return [nums[i] for i in nums]


s056 = Solution056()
r056 = s056.buildArray([5, 0, 1, 2, 3, 4])
print(r056)  # [4, 5, 0, 1, 2, 3]


# 057: 数组串联
# 给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，
# 对于所有 0 <= i < n 的 i ，满足下述所有要求：
# ans[i] == nums[i]
# ans[i + n] == nums[i]
# 具体而言，ans 由两个 nums 数组 串联 形成。
# 示例 1：
# 输入：nums = [1,2,1]
# 输出：[1,2,1,1,2,1]
# 解释：数组 ans 按下述方式形成：
# - ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
# - ans = [1,2,1,1,2,1]

# 示例 2：
# 输入：nums = [1,3,2,1]
# 输出：[1,3,2,1,1,3,2,1]
# 解释：数组 ans 按下述方式形成：
# - ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
# - ans = [1,3,2,1,1,3,2,1]

class Solution057:
    def getConcatenation(self, nums: list[int]) -> list[int]:
        # return nums * 2    # 解法1，但是销毁比较大。
        return nums + nums  # 解法2，销毁比较小。


s057 = Solution057()
r057 = s057.getConcatenation([5, 0, 1])
print(r057)  # [5, 0, 1, 5, 0, 1]


# 058: 数组串联
#  给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 
# S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
# J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
# 示例 1:
# 输入: J = "aA", S = "aAAbbbb"
# 输出: 3

# 示例 2:
# 输入: J = "z", S = "ZZ"
# 输出: 0

class Solution058:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        number = 0
        for i in stones:
            if i in jewels:
                number += 1
        return number


s058 = Solution058()
r058 = s058.numJewelsInStones("peace", "AbcDef")
print(r058)  # ce - >　２


# 059: 统计匹配检索规则的物品数量
# 给你一个数组 items ，其中 items[i] = [typei, colori, namei] ，描述第 i 件物品的类型、颜色以及名称。
# 另给你一条由两个字符串 ruleKey 和 ruleValue 表示的检索规则。
# 如果第 i 件物品能满足下述条件之一，则认为该物品与给定的检索规则 匹配 ：
# ruleKey == "type" 且 ruleValue == typei 。
# ruleKey == "color" 且 ruleValue == colori 。
# ruleKey == "name" 且 ruleValue == namei 。
# 统计并返回 匹配检索规则的物品数量 。

# 示例 1：
# 输入：items = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]],
# ruleKey = "color", ruleValue = "silver"
# 输出：1
# 解释：只有一件物品匹配检索规则，这件物品是 ["computer","silver","lenovo"] 。
#
# 示例 2：
# 输入：items = [["phone","blue","pixel"],["computer","silver","phone"],["phone","gold","iphone"]],
# ruleKey = "type", ruleValue = "phone"
# 输出：2
# 解释：只有两件物品匹配检索规则，这两件物品分别是 ["phone","blue","pixel"] 和 ["phone","gold","iphone"] 。
# 注意，["computer","silver","phone"] 未匹配检索规则。

class Solution059:
    def countMatches(self, items: list[list[str]], ruleKey: str, ruleValue: str) -> int:
        count = 0
        k = ["type", "color", "name"]

        word_index = k.index(ruleKey)

        for i in items:
            for index, value in enumerate(i):
                if index == word_index and value == ruleValue:
                    count += 1
        return count


s059 = Solution059()
items059 = [["phone", "blue", "pixel"], ["computer", "silver", "phone"], ["phone", "gold", "iphone"]]

r059 = s059.countMatches(items059, "type", "phone")
print(r059)  # 2


# 060: 数组异或操作
# 给你两个整数，n 和 start 。
# 数组 nums 定义为：nums[i] = start + 2*i（下标从 0 开始）且 n == nums.length 。
# 请返回 nums 中所有元素按位异或（XOR）后得到的结果。
# 示例 1：
# 输入：n = 5, start = 0
# 输出：8
# 解释：数组 nums 为 [0, 2, 4, 6, 8]，其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。"^" 为按位异或 XOR 运算符。
#
# 示例 2：
# 输入：n = 4, start = 3
# 输出：8
# 解释：数组 nums 为 [3, 5, 7, 9]，其中 (3 ^ 5 ^ 7 ^ 9) = 8.
#
# 示例 3：
# 输入：n = 1, start = 7
# 输出：7


class Solution060:
    def xorOperation(self, n: int, start: int) -> int:
        new_list = [start + 2 * i for i in range(n)]
        result = 0
        for i in new_list:
            result = result ^ i
        return result


s060 = Solution060()
r060 = s060.xorOperation(4, 3)
print(r060)  # 8