thảo luận Leetcode mỗi ngày

class Solution {
    public boolean isCircularSentence(String sentence) {
        String[] words = sentence.split("\\s+");
        if (words.length == 1) {
            if (words[0].charAt(0) == words[0].charAt(words[0].length() - 1)) return true;
            return false;
        }
        for (int i = 1; i < words.length; i++) {
            if (words[i - 1].charAt(words[i - 1].length() - 1) != words[i].charAt(0)) return false;
            if (i == words.length - 1) {
                if (words[i].charAt(words[i].length() - 1) != words[0].charAt(0)) return false;
            }
        }
        return true;
    }
}

class Solution {
    public boolean isCircularSentence(String sentence) {
        String[] arr = sentence.split(" ");
        int n = arr.length;
        char pre = arr[n-1].charAt(arr[n-1].length()-1);
        for(String s: arr){
            if(pre != s.charAt(0))
                return false;
            pre = s.charAt(s.length()-1);
        }
        return true;
    }
}

#define i64 long long
class Solution {
public:
    int kConcatenationMaxSum(vector<int>& a, int k) {
        i64 mod = 1e9+7;
        a.insert(a.end(), a.begin(), a.end());
        int n=a.size();
        i64 msf=0,cm=0,res=-1e18,s=0;
        for(int i=0;i<n;i++){
            if(i<n/2){
                s+=a[i];
                s%=mod;
            }
            if(k==1&&i==n/2) break;
            cm=max((i64)a[i],cm+a[i]);
            msf=max(msf,cm);
        }
        msf%=mod;
        if(s>0&&k>2){
            return (msf+(s*(k-2))%mod)%mod;
        }
        return msf;
    }
};

class Solution {
    public static final int MOD = 1_000_000_007;
    public int kConcatenationMaxSum(int[] arr, int k) {
        int n = arr.length * Math.min(k, 3);
        long maximumSumSubArray = 0;
        int prev = 0;
        for (int i = 0; i < n; i++) {
            int curMax = Math.max(
                prev + arr[i % arr.length],
                arr[i % arr.length]
            );
            maximumSumSubArray = Math.max(
                curMax,
                maximumSumSubArray
            );
            prev = curMax;
        }

        long sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        if (sum * Math.min(k, 3) == maximumSumSubArray) {
            return (int)((sum % MOD * k) % MOD);
        }

        if (sum > 0 && k > 2) {
            return Math.max(
                (int) maximumSumSubArray % MOD,
                (int) (maximumSumSubArray - sum + (k - 2) * sum % MOD) % MOD
            );
        } else {
            return (int)(maximumSumSubArray % MOD);
        }

    }
}

class Solution {
public:
    bool isCircularSentence(string sentence) {
        if (sentence.back() != sentence.front()) return false;
        for (auto p = sentence.begin(); p < sentence.end(); ++p) {
            if (*p == ' ' && *(p - 1) != *(p + 1)) return false;
        }
        return true;
    }
};

impl Solution {
    pub fn is_circular_sentence(sentence: String) -> bool {
        if sentence.chars().nth(0).unwrap() != sentence.chars().last().unwrap() {
            return false;
        }

        let mut last = '.';

        for word in sentence.split(" ") {
            if last != '.' && last != word.chars().nth(0).unwrap() {
                return false;
            }
            last = word.chars().last().unwrap();
        }

        true
    }
}

class Solution {
    func isCircularSentence(_ sentence: String) -> Bool {
        let sentence = [Character](sentence)
        let first = sentence[0]
        var pre1 = first
        var pre2 = pre1
        for char in sentence {
            if pre2 == " " && char != pre1 {
                return false
            }
            pre1 = pre2
            pre2 = char
        }
        return first == pre2
    }
}

func isCircularSentence(sentence string) bool {
    result := true
    arr := strings.Split(sentence, " ")
    for i := range arr {
        if i+1 < len(arr) {
            if arr[i][len(arr[i])-1] != arr[i+1][0] {
                result = false
                break
            }
        } else {
            if arr[i][len(arr[i])-1] != arr[0][0] {
                result = false
            }
        }
    }
    return result
}

public class Solution {
    public bool IsCircularSentence(string sentence) {
        List<string> list = sentence.Split(' ').ToList();
        if (sentence[sentence.Length - 1] != sentence[0])
            return false;
        for (int i = 1; i < list.Count; i++)
            if (list[i][0] != list[i-1][list[i-1].Length-1])
                return false;
        return true;
    }
}

class Solution {
    public boolean isCircularSentence(String sentence) {
        var words = sentence.split(" ");
        
        for (int i = 0; i < words.length; i++) {
            char lastChar = words[i].charAt(words[i].length() - 1);
            char firstChar = words[(i + 1) % words.length].charAt(0);
            if (lastChar != firstChar) {
                return false;
            }
        }
        
        return true;
    }
}

class Solution {
    public boolean isCircularSentence(String sentence) {
        if (sentence.charAt(0) != sentence.charAt(sentence.length() - 1)) {
            return false;
        }
        
        String[] words = sentence.split(" ");
        for (int i = 1; i < words.length; i++) {
            if (words[i - 1].charAt(words[i - 1].length() - 1) != words[i].charAt(0)) {
                re turn false;
            }
        }
        
        return true;
    }
}

class Solution(object):
    def isCircularSentence(self, sentence):
        """
        :type sentence: str
        :rtype: bool
        """
        list_w = sentence.split()
        for i in range(len(list_w)):
            if list_w[i-1][-1] != list_w[i][0] :
                return False
        return True

class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        if len(s) != len(goal):
            return False

        MOD = 2**64 - 1
        BASE = randint(1000, 10000)
        n = len(s)
        lastBase = pow(BASE, n - 1, MOD)
        def calculateHash(string):
            currentHash = 0
            for i, val in enumerate(string):
                order = ord(val) - ord('a')
                currentHash = currentHash*BASE + order
                currentHash%=MOD

            return currentHash

        targetHash = calculateHash(goal)
        currentHash = calculateHash(s)
        if currentHash == targetHash:
            return True

        left = 0
        for i in range(n):
            currentHash = currentHash - (ord(s[left]) - ord('a'))*lastBase
            if currentHash < 0:
                currentHash += MOD

            left += 1
            currentHash = currentHash*BASE + ord(s[i]) - ord('a')
            currentHash %= MOD
            if currentHash == targetHash:
                return True

        return False

class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        return len(s) == len(goal) and (s + s).find(goal) != -1

class Solution {
public:
    bool rotateString(string s, string goal) {
        if (s.length() != goal.length())
            return false;
        size_t pos = -1;
        size_t i;
        while (string::npos != (pos = goal.find(s[0], pos + 1))) {
            i = 0;
            for (i = 0; i < goal.length(); ++i) {
                if (s[i] != goal[(pos + i) % goal.length()])
                    break;
            }
            if (i == goal.length())
                return true;
        }
        return false;
    }
};