LeetCode Python [mise à jour]

introduction

――Parce que j'utilise Ruby au travail, j'ai principalement résolu la programmation compétitive avec Ruby, mais au prochain travail, je pratiquerai Python petit à petit chaque jour pour utiliser Python et le laisser dans Qiita sous forme de mémorandum. Le sujet est Let Code.

• Je ne suis pas familier avec Python, alors n'hésitez pas à commenter.

Easy 1108.Defanging an IP Address --Résumé: Remplacez. Par [.]

• Input: "1.1.1.1"
• Expected: "1[.]1[.]1[.]1" --Remplacer: ** remplacer **

class Solution:
    def defangIPaddr(self, address: str) -> str:
        return address.replace(".","[.]") 

771.Jewels and Stones --Résumé: comptez le nombre de lettres J dans S

• Input: J = "aA", S = "aAAbbbb"
• Output: 3 --Réponse 1: Utilisez des chaînes comme des tableaux --Faites une chaîne dans un tableau: ** list **
• Nombre de caractères: ** nombre **

class Solution:
    def numJewelsInStones(self, J: str, S: str) -> int:
        cnt = 0
        chars = list(J)
        for e in chars:
            cnt += S.count(e)
        return cnt

• Réponse 2: Utilisez des chaînes comme des tableaux --Je ne savais pas que les chaînes pouvaient être traitées comme des tableaux. --pour x dans la chaîne:

class Solution:
    def numJewelsInStones(self, J: str, S: str) -> int:
        cnt = 0
        for e in J:
            cnt += S.count(e)
        return cnt

• Réponse 3: Utiliser la fonction anonyme ――Je pense que Python lambda est une carte en Ruby. --La forme est spéciale et traitement pour les tableaux (map (variable lambda: traitement des variables, arguments))

class Solution:
    def numJewelsInStones(self, J: str, S: str) -> int:
        return sum(map(lambda x:S.count(x),J))

1281.Subtract the Product and Sum of Digits of an Integer --Summary: Nombre de tous les chiffres multiplié par --- Nombre de tous les chiffres ajoutés

• Input: n = 234
• Output: 15
• Réponse 1: Calculer comme un tableau avec lambda --Créez un tableau numérique avec le lambda dont vous venez de vous souvenir. Avec Ruby, vous pouvez immédiatement imaginer avec map et to_i --String => Entier: ** int ** --Integer => Chaîne: ** str **

class Solution:
    def subtractProductAndSum(self, n: int) -> int:
        ary = list(map(lambda x: int(x), list(str(n))))
        n = 1
        m = 0
        for i in ary:
            n *= i
        for j in ary:
            m += j
        ans = n - m
        return ans

• Réponse 2: Calculer comme un tableau de chaînes (Forme sophistiquée de la réponse 1) --Utiliser **; ** pour plusieurs tâches --Utiliser **: ** en unités de bloc?

class Solution:
    def subtractProductAndSum(self, n: int) -> int:
        a, b = 0, 1
        for i in str(n): a += int(i); b *= int(i)
        return b - a

1221.Split a String in Balanced Strings

• Résumé: Combien de paires de R et L peuvent être créées à la condition que R et L doivent avoir le même nombre de caractères?
• Input: s = "RLRRLLRLRL"
• Output: 4 --Réponse 1: Comptez le nombre de paires en réglant 1 si R apparaît et -1 si L apparaît.

class Solution:
    def balancedStringSplit(self, s: str) -> int:
        r = 0
        output = 0
        for e in s:
            if e == 'R':
                r += 1
            if e == 'L':
                r -= 1
            
            if r == 0:
                output += 1
        return output