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

class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        return  len(s) == len(goal) and goal in s * 2

class Solution {
    public boolean rotateString(String s, String goal) {
        int n = s.length();
        int m = goal.length();
        if(n!=m) return false;
        int cnt =0;
        for(int i =0 ; i < n;i++){
            if(s.charAt(i)==goal.charAt(0)){
                cnt=1;
                for(int j = 1;j<n;j++){
                    if(s.charAt((i+j)%n) == goal.charAt(j)) cnt++;
                }
                if(cnt==n) return true;
            }
        }
        return false;
    }
}

impl Solution {
    pub fn rotate_string(s: String, goal: String) -> bool {
        if s.len() != goal.len() {
            return false;
        }

        if s == goal {
            return true;
        }

        for i in 1..s.len() {
            let (first, second) = s.split_at(i);

            if goal.starts_with(second) && goal.ends_with(first) {
                return true;
            }
        }

        false
    }
}

class Solution {
    public boolean rotateString(String s, String goal) {
        return s.length() == goal.length() && (s + s).contains(goal);
    }
}

class Solution {
public:
    bool rotateString(string s, string goal) {
        int N = s.size();
        s = s + s;
        for (int i = 0; i < N; i++) {
            if (s.substr(i, N) == goal) return true;
        }
        return false;
    }
};

impl Solution {
    pub fn rotate_string(s: String, goal: String) -> bool {
        const BASE: usize = 197;
        const MODULO: usize = 48619;
        if s.len() != goal.len() {
            return false;
        }
        let (mut s, goal) = (s.into_bytes(), goal.as_bytes());
        let (mut hash_s, hash_goal, high_mod) = {
            let (mut hs, mut hg, mut hm) = (0usize, 0usize, 1usize);
            for i in 0..goal.len() {
                hs = (hs + s[i] as usize) * BASE % MODULO;
                hg = (hg + goal[i] as usize) * BASE % MODULO;
                hm = hm * BASE % MODULO;
            }
            (hs, hg, hm)
        };
        hash_s == hash_goal || {
            s.extend(s.clone());
            s.iter().skip(goal.len()).enumerate().any(|(i, &c)| {
                hash_s = (hash_s + MODULO - s[i] as usize * high_mod % MODULO + c as usize)
                        * BASE
                        % MODULO;
                hash_s == hash_goal
            })
        }
    }
}

/**
 * @param {string} s
 * @param {string} goal
 * @return {boolean}
 */
var rotateString = function(s, goal) {
    if (s.length !== goal.length) return false;
    if (s === goal) return true;

    for (let i=0; i<s.length; i++) {
        let rotate = s.substring(1) + s[0];
        if (rotate === goal) return true;
        s = rotate;
    }

    return false;
};

class Solution {
    public boolean rotateString(String s, String goal) {
        StringBuilder sb = new StringBuilder(s);
        if (s.length() != goal.length()) return false;
        for (int i = 0; i < s.length(); i++) {
            if (sb.toString().equals(goal)) return true;
            sb.deleteCharAt(0).append(s.charAt(i));
        }
        return false;
    }
}

class Solution {
    public boolean rotateString(String s, String goal) {
        return goal.length()==s.length() && (s+s).contains(goal);
    }
}

impl Solution {
    pub fn rotate_string(s: String, goal: String) -> bool {
        let (m, n) = (s.len(), goal.len());

        if m != n {
            return false;
        }

        let (s_bytes, goal_bytes) = (s.as_bytes(), goal.as_bytes());
        let mut z = vec![0; m * 2];
        let (mut left, mut right) = (0, 0);

        for l in 0..(2 * n) {
            if l < right {
                z[l] = (right - l).min(z[l - left]);
            }

            while (z[l] < n && l + z[l] < 2 * n && s_bytes[z[l]] == goal_bytes[(l + z[l]) % n]) {
                z[l] += 1;
            }

            if (l + z[l] > right) {
                left = l;
                right = l + z[l];
            }
        }

        z.into_iter().any(|len| len == n)
    }
}

class Solution {
public:
    bool rotateString(string s, string goal) {
       
        int n = s.length();
        bool ans = false;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (s[(i + j) % n] != goal[j]) {
                    break;
                }
                if (j == n - 1) ans = true;
            }
            if (ans) break;
        }
       
        return ans;
    }
};

public class Solution {
    public bool RotateString(string s, string goal) {
        int i = 0;
        while (true)
        {
            if(s.CompareTo(goal) == 0)
                return true;
            i++;
            if(i>s.Length)
                return false;
            goal += goal[0];
            goal = goal[1..];
        }
    }
}

func RotateString(s string, goal string) bool {
    if len(s) != len(goal) {
        return false
    }
    return strings.Contains(s+s, goal)
}

class Solution {
    public boolean rotateString(String s, String goal) {
        int n = s.length();
        int m = goal.length();
        if(n!=m) return false;
        int cnt =0;
        long hashed  = 0;
        long hash = 0;
        int BASE = 29;
        long MOD = 1000000007L;
        long h = 1;
        for(int i= 0;i<n-1;i++){
             h =(h%MOD*BASE%MOD)%MOD;
        }
        for(int i  =0;i<n;i++){
            hashed= (hashed*BASE + (goal.charAt(i)-'a'))%MOD;
            hash=(hash*BASE+(s.charAt(i)-'a'))%MOD;
        }
        System.out.println(h);
        for(int i = 0;i<=n;i++){
          
            if(hash==hashed)
            {
                return true;
            }
            if(i==n) break;
            int c = s.charAt(i)-'a';
            System.out.println(hash-c*h+MOD);
            hash = (BASE*(hash-c*h)+c)%MOD;
            if(hash<0)hash+=MOD;         
        }
        return false;
    }
}