831. Masking Personal Information

Problem Description

This problem involves designing an algorithm to mask personal information. Personal information can be an email address or a phone number, and each has specific rules for masking.

Email Address Masking Rules:

• Transform all uppercase letters in the name and domain parts of the email address to lowercase.
• Mask all but the first and last letter of the name part with five asterisks (*****).

Phone Number Masking Rules:

• Remove all separation characters (which may include +, -, (, ), and spaces) to only retain digits.
• Format the number based on the leftover digit count after the local number (last 10 digits). The formatting is as follows:
  • If there is no country code, the format is ***-***-XXXX, where XXXX is the last four digits of the local number.
  • If there is a country code, it should be represented by the same number of asterisks as digits, followed by the formatted local number ***-***-XXXX.

The algorithm must identify whether the provided string is an email or a phone number and mask it accordingly.

Intuition

The intuition behind solving this problem starts with identifying if the given s is an email address or a phone number. This can usually be identified by the presence of alphabetic characters and the special character @. If s[0] is an alphabetic character, it is an email, otherwise it's a phone number.

For an email address:

1. Convert the entire string to lowercase to satisfy the case-insensitivity requirement.
2. Replace the middle part of the name with five asterisks, but maintain the first character, the character before the @, and the complete domain after the @.

For a phone number:

1. Remove all separation characters by filtering out non-digit characters, leaving only the digits.
2. The number of characters remaining after the last 10 gives us the number of digits in the country code. Depending on this count, mask the country code with asterisks.
3. The last 4 digits of the local number remain unmasked, while the others are replaced by asterisks, keeping consistent with the ***-***- prefix.

The provided solution uses Python comprehensions to filter and the string methods to replace and format according to the rules. The code is compact and only uses conditional logic to distinguish the masking process between an email address and a phone number.

Solution Approach

The implementation of the masking algorithm can be broken down into several steps and patterns used throughout the code:

1. Determining the Type of Personal Information: The algorithm first checks if the given string s represents an email address or a phone number. This is done by checking the first character of the string:

   1if s[0].isalpha():

   If the first character is an alphabetical letter, it is an email address; otherwise, it is a phone number.

2. Email Masking:

   • All characters of the email address are converted to lowercase using lower() to ensure case insensitivity.
   • The first and the last character of the name part, along with the domain, are preserved.
   • The middle part of the name is replaced with five asterisks (*****).

   1return s[0] + '*****' + s[s.find('@') - 1 :]

3. Phone Number Masking:

   • All non-digit characters are filtered out, leaving only digits in the string:

     1s = ''.join(c for c in s if c.isdigit())

   • The algorithm calculates the length of the country code by subtracting 10 from the total length of the filtered digits. This is because the local number always consists of the last 10 digits.
   • A switch-like statement, using if-elif, is avoided. Instead, a more elegant formatting via an f-string and repetition of asterisk characters is used to handle different lengths of country codes:

     1cnt = len(s) - 10
     2suf = '***-***-' + s[-4:]
     3return suf if cnt == 0 else f'+{"*" * cnt}-{suf}'

In summary, the solution makes use of string methods (like lower() and find()), list comprehensions (to filter characters), and string concatenation to assemble the masked personal information. It uses the compactness of Python's string formatting to keep the code concise and readable. There is no explicit usage of complex data structures as the operations are basic string manipulations. This approach is efficient because it goes through the string at most two times: once to either lower the case of the characters (for emails) or filter digits (for phone numbers), and once to construct the masked string. This is essentially O(n) complexity, where n is the length of the input string.

Example Walkthrough

Let's walk through a small example illustrating the solution approach for both an email and a phone number.

Email Example

Given the email [email protected], let's apply the solution approach:

1. Since the first character 'E' is an alphabetical letter, we identify the string as an email address.
2. Convert the email to lowercase: [email protected].
3. Preserve the first and the last character of the name part and the entire domain: 'e' and 'l' are the two characters we preserve from exampleemail.
4. Replace the middle part of the name with five asterisks: e*****[email protected].

After following these steps, we get the masked email address: e*****[email protected].

Phone Number Example

Given the phone number +1 (234) 567-8901, let's apply the solution approach:

1. The first character '+' indicates it's a phone number.
2. Remove all non-digit characters, leaving only the digits: 12345678901.
3. Identify the country code, which in this case is '1', by counting the digits beyond the last 10, which gives us 1 digit here.
4. Replace the country code with an asterisk and apply the standard mask for the remaining number, preserving the last four digits: * ***-***-8901.

After following these steps, we get the masked phone number: * ***-***-8901.

These two examples demonstrate how the algorithm distinguishes between email addresses and phone numbers and how it applies the respective masking rules to conceal personal information while following the specified format.

Solution Implementation

Time and Space Complexity

Time Complexity:

The time complexity of the maskPII function is determined by several operations that the function performs:

1. Checking whether the first character is alphabetical: O(1), since it's a constant-time check on a single character.

2. Converting the string to lower case if it's an email: O(n), where n is the length of the string s.

3. Finding the position of '@' in the string: O(n) in the worst case, since it requires scanning the string in case of an email address.

4. Stripping non-digit characters and joining digits into a new string: O(n), because each character of the original string s is checked once.

5. Constructing the masked string: The actual construction is O(1) because we are appending fixed strings and characters to a masked result.

Combining these, the time complexity is dictated by the string operations, which are linear in the length of the input string s. Therefore, the time complexity is O(n).

Space Complexity:

The space complexity is determined by the additional space used by the function:

1. A new lower case email id string if s[0].isalpha(): O(n) space for the new string.

2. The list comprehension that filters digits: O(n) space for the new list of characters before it is joined into a string.

3. The final masked string has a constant size related to the format of the phone number or email (O(1) space), not dependent on the input size.

Thus, the dominating factor is the creation of new strings, which takes O(n) space. Hence, the space complexity is O(n).

Learn more about how to find time and space complexity quickly using problem constraints.