A token is a valid word if:

• It only contains lowercase letters, hyphens, and/or punctuation (no digits).
• There is at most one hyphen '-'. If present, it should be surrounded by lowercase characters ("a-b" is valid, but "-ab" and "ab-" are not valid).
• There is at most one punctuation mark. If present, it should be at the end of the token.

Examples of valid words include "a-b.", "afad", "ba-c", "a!", and "!".

Given a string sentence, return the number of valid words in sentence.

Example 1:

Input: sentence = "cat and  dog"
Output: 3
Explanation: The valid words in the sentence are "cat", "and", and "dog".

Example 2:

Input: sentence = "!this  1-s b8d!"
Output: 0
Explanation: There are no valid words in the sentence.
"!this" is invalid because it starts with a punctuation mark.
"1-s" and "b8d" are invalid because they contain digits.

Example 3:

Input: sentence = "alice and  bob are playing stone-game10"
Output: 5
Explanation: The valid words in the sentence are "alice", "and", "bob", "are", and "playing".
"stone-game10" is invalid because it contains digits.

Example 4:

Input: sentence = "he bought 2 pencils, 3 erasers, and 1  pencil-sharpener."
Output: 6
Explanation: The valid words in the sentence are "he", "bought", "pencils,", "erasers,", "and", and "pencil-sharpener.".

Constraints:

• 1 <= sentence.length <= 1000
• sentence only contains lowercase English letters, digits, ' ', '-', '!', '.', and ','.
• There will be at least 1 token.

Solution 1: Brute Force

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countValidWords(string sentence) {
    stringstream ss(sentence);
    string word;
    int ans = 0;
    while (ss >> word) {      
      bool valid = true;      
      int hyphen = 0;
      int punctuation = 0;
      char p = ' ';
      for (char c : word) {
        if (c == '-') {          
          if (++hyphen > 1 || !isalpha(p)) {
            valid = false;
            break;
          }
        } else if (c == '!' || c == '.' || c == ',') {
          if (++punctuation > 1 || p == '-') {
            valid = false;
            break;
          }
        } else if (isalpha(c)) {          
          if (punctuation) {
            valid = false;
            break;
          }
        } else {
          valid = false;
          break;
        }
        p = c;
      }
      if (word.back() == '-') 
        valid = false;
      if (valid) ++ans;      
    }
    return ans;
  }  
};

Solution 2: Regex

Time complexity: O(n^2)?
Space complexity: O(1)

# Author: Huahua
class Solution:
  def countValidWords(self, sentence: str) -> int:
    ans = 0
    for word in sentence.split():
      if word.strip() and re.fullmatch('^([a-z]+(-?[a-z]+)?)?[\.,!]?$', word.strip()):
        ans += 1
    return ans

The post 花花酱 LeetCode 2047. Number of Valid Words in a Sentence appeared first on Huahua's Tech Road.

Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

Note:

• s could be empty and contains only lowercase letters a-z.
• p could be empty and contains only lowercase letters a-z, and characters like . or *.

Example 1:

Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" does not match the entire string "aa".

Example 2:

Input:
s = "aa"
p = "a*"
Output: true
Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".

Example 3:

Input:
s = "ab"
p = ".*"
Output: true
Explanation: ".*" means "zero or more (*) of any character (.)".

Example 4:

Input:
s = "aab"
p = "c*a*b"
Output: true
Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".

Example 5:

Input:
s = "mississippi"
p = "mis*is*p*."
Output: false

Solution 1: Recursion

Time complexity: O((|s| + |p|) * 2 ^ (|s| + |p|))

Space complexity: O(|s| + |p|)

// Author: Huahua, 14 ms
class Solution {
public:
  bool isMatch(string s, string p) {
    return isMatch(s.c_str(), p.c_str());
  }
private:
  bool isMatch(const char* s, const char* p) {
    if (*p == '\0') return *s == '\0';
        
    // normal case, e.g. 'a.b','aaa', 'a'
    if (p[1] != '*' || p[1] == '\0') {
      // no char to match
      if (*s == '\0') return false;

      if (*s == *p || *p == '.')
        return isMatch(s + 1, p + 1);
      else
        return false;
    }
    else {
      int i = -1;
      while (i == -1 || s[i] == p[0] || p[0] == '.') {
          if (isMatch(s + i + 1, p + 2)) return true;
          if (s[++i] == '\0') break;
      }
      return false;
    }
    
    return false;
  }
};

The post 花花酱 LeetCode 10. Regular Expression Matching appeared first on Huahua's Tech Road.

Problem

You are given a string representing an attendance record for a student. The record only contains the following three characters:

1. ‘A’ : Absent.
2. ‘L’ : Late.
3. ‘P’ : Present.

A student could be rewarded if his attendance record doesn’t contain more than one ‘A’ (absent) or more than two continuous ‘L’ (late).

You need to return whether the student could be rewarded according to his attendance record.

Example 1:

Input: "PPALLP"
Output: True

Example 2:

Input: "PPALLL"
Output: False

Solution1: Simulation

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
// Running time: 3 ms
class Solution {
public:
  bool checkRecord(string s) {
    int a{0};
    int l{0};
    for(char c: s) {
        if (c == 'A') ++a;
        if (c == 'L') ++l;
        else l=0;
        if (a > 1 || l > 2) return false;
    }
    return true;
  }
};

Solution 2: Regex

// Author: Huahua
// Running time: 6 ms
class Solution {
public:
  bool checkRecord(string s) {
    return !std::regex_search(s, std::regex("A.*A|LLL"));
  }
};

The post 花花酱 LeetCode 551. Student Attendance Record I appeared first on Huahua's Tech Road.

Write a function to check whether an input string is a valid IPv4 address or IPv6 address or neither.

IPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal numbers, each ranging from 0 to 255, separated by dots (“.”), e.g.,172.16.254.1;

Besides, leading zeros in the IPv4 is invalid. For example, the address 172.16.254.01 is invalid.

IPv6 addresses are represented as eight groups of four hexadecimal digits, each group representing 16 bits. The groups are separated by colons (“:”). For example, the address 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is a valid one. Also, we could omit some leading zeros among four hexadecimal digits and some low-case characters in the address to upper-case ones, so 2001:db8:85a3:0:0:8A2E:0370:7334 is also a valid IPv6 address(Omit leading zeros and using upper cases).

However, we don’t replace a consecutive group of zero value with a single empty group using two consecutive colons (::) to pursue simplicity. For example, 2001:0db8:85a3::8A2E:0370:7334 is an invalid IPv6 address.

Besides, extra leading zeros in the IPv6 is also invalid. For example, the address 02001:0db8:85a3:0000:0000:8a2e:0370:7334 is invalid.

Note: You may assume there is no extra space or special characters in the input string.

Example 1:

<b>Input:</b> "172.16.254.1"

<b>Output:</b> "IPv4"

<b>Explanation:</b> This is a valid IPv4 address, return "IPv4".

Example 2:

<b>Input:</b> "2001:0db8:85a3:0:0:8A2E:0370:7334"

<b>Output:</b> "IPv6"

<b>Explanation:</b> This is a valid IPv6 address, return "IPv6".

Example 3:

<b>Input:</b> "256.256.256.256"

<b>Output:</b> "Neither"

<b>Explanation:</b> This is neither a IPv4 address nor a IPv6 address.

Solution 1: String / Brute force 

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  bool isV4Num(string n) {
    if (n.length() > 3 || n.empty()) return false;
    std::reverse(n.begin(), n.end());
    int a = 0;    
    int f = 1;
    for (char c : n) {
      if (!isdigit(c)) return false;
      if (c == '0' && f > 1) return false;
      a += (c - '0') * f;
      f *= 10;
    }
    return a >= 0 && a <= 255;
  }
  
  bool isV6Num(string n) {
    if (n.length() > 4 || n.empty()) return false;
    std::reverse(n.begin(), n.end());
    
    int a = 0;
    int f = 1;    
    for (char c : n) {      
      if (isdigit(c)) 
        a += (c - '0') * f;
      else if (c >= 'a' && c <= 'f' || c >= 'A' && c <= 'Z')
        a += (tolower(c) - 'a' + 10) * f;
      else
        return false;
      f *= 16;
    }
    
    return a >= 0 && a < (1 << 16);
  }
  
  string validIPAddress(string IP) {
    bool isIPv4 = true;
    bool isIPv6 = true;
    string cur;
    int seg = 0;
    for (char c: IP) {
      if (c == '.') { ++seg; isIPv6 = false; isIPv4 &= isV4Num(cur); cur.clear(); }
      else if (c == ':') { ++seg; isIPv4 = false; isIPv6 &= isV6Num(cur); cur.clear(); }
      else cur += c;
    }
    isIPv4 &= isV4Num(cur) && seg == 3;
    isIPv6 &= isV6Num(cur) && seg == 7;
    
    return isIPv4 ? "IPv4" : (isIPv6 ? "IPv6" : "Neither");
  }
};

The post 花花酱 LeetCode 468. Validate IP Address appeared first on Huahua's Tech Road.