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

Ruby: 
# @param {Integer[]} nums
# @return {Integer}
def find_max_k(nums)
    track = Set.new
    ans = -1
    nums.each do |num|
        track.add(num)
        if track.include?(-num)
            ans = [ans, num.abs].max
        end
    end
    return ans
end
 
PHP: 
class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function findMaxK($nums) {
        $stack = [];
        $max = -1;
        foreach ($nums as $n) {
            if ($n < 0) {
                if (isset($stack[-$n])) {
                    $stack[$n] = -$n;
                    $max = ($stack[$n] > $max) ? $stack[$n] : $max;
                } else $stack[$n] = 0;
            } else {
                if (isset($stack[-$n])) {
                    $stack[-$n] = $n;
                    $max = ($stack[-$n] > $max) ? $stack[-$n] : $max;
                }
                $stack[$n] = 0;
            }
        }
        
        return $max;
    }
}
 
Last edited:
Thất nghiệp ngồi giải leetcode :too_sad:
C#: 
public class Solution {
    public int FindMaxK(int[] nums) {
        var hashSet = new HashSet<int>(nums);
        int result = -1;
        for(int i=0;i<nums.Length;i++)
        {
            if(nums[i] > result && hashSet.Contains(-nums[i]))
            {
                result = nums[i];
            }
        }
        return result;
    }
}
 
Bài dễ mới dám vào làm. Đang học ít ML với code Python High performant đi xin việc hay bị hỏi. :shame:
Python: 
class Solution:
    def findMaxK(self, nums: List[int]) -> int:
        dic = {}
        max_num = -1
        for num in nums:
            dic[num] = 1
            if dic.get(-num, 0) == 1:
                if abs(num) > max_num:
                    max_num = abs(num)
        return max_num
 
mưa gió đến cty khó chịu vl, code xấu quá pass nhưng chưa tối ưu. Để đây tối post lại.
Những bài ntn dùng python rất sướng vì hỗ trợ tận răng.

Edit: trả bài
Python: 
class Solution:
    def compareVersion(self, version1: str, version2: str) -> int:
        lst1 = [int(v) for v in version1.split('.')]
        lst2 = [int(v) for v in version2.split('.')]
        n = max(len(lst1), len(lst2))

        for i in range(n):
            v1 = lst1[i] if i < len(lst1) else 0
            v2 = lst2[i] if i < len(lst2) else 0
            if v1 > v2: return 1
            if v1 < v2: return -1

        return 0

C++: 
    int compareVersion(string version1, string version2) {
        int n1 = version1.size(), n2 = version2.size();
        long long v1 = 0, v2 = 0;
        int k1 = 0, k2 = 0;
        while(k1 < n1 || k2 < n2) {
            v1 = v2 = 0;
            
            while(k1 < n1 && version1[k1] != '.') {
                v1 = v1 * 10 + version1[k1] - '0';
                k1++;
            }
            
            while(k2 < n2 && version2[k2] != '.') {
                v2 = v2 * 10 + version2[k2] - '0';
                k2++;
            }

            if (v1 < v2) return -1;
            if (v1 > v2) return 1;
            
            ++k1, ++k2; // Ignore '.'
        }
        return 0;
    }
 
Last edited:
O(1) cũng đc mà lười
Python: 
class Solution:
    def compareVersion(self, version1: str, version2: str) -> int:
        version1Numbers = version1.split(".")
        version2Numbers = version2.split(".")
        m = len(version1Numbers)
        n = len(version2Numbers)
        maxLength = max(m, n)
        for i in range(maxLength):
            v1 = int(version1Numbers[i]) if i < m else 0
            v2 = int(version2Numbers[i]) if i < n else 0
            if v1 < v2:
                return -1
            elif v1 > v2:
                return 1
        return 0
 
Last edited:
freedom.9 said:
O(1) cũng đc mà lười
Python: 
class Solution:
    def compareVersion(self, version1: str, version2: str) -> int:
        version1Numbers = version1.split(".")
        version2Numbers = version2.split(".")
        maxLength = max(len(version1Numbers), len(version2Numbers))
        for i in range(maxLength):
            v1 = int(version1Numbers[i]) if i < len(version1Numbers) else 0
            v2 = int(version2Numbers[i]) if i < len(version2Numbers) else 0
            if v1 < v2:
                return -1
            elif v1 > v2:
                return 1
        return 0

    def toInteger(self, version: str) -> int:
        currentNumber = 0
        left = 0
        while left < len(version):
            currentNumber = currentNumber * 10 + (ord(version[left]) - ord('0'))
            left += 1
        return currentNumber
Click to expand...
Tiện thể của thím có thể sửa lại dễ hơn đấy
version1Numbers = [int(v) for v in version1.split('.')]
version2Numbers = [int(v) for v in version2.split('.')]
Hàm toInteger thừa à
 
Last edited:

Đây là 2 solutions của mình, ae góp ý với ạ, xin cảm ơn​

2 Approaches, both beat 100% (Two pointers, Recursion)​

Approach​

  • Compare numbers in the front of "." until both strings are empty

Complexity​

  • Time complexity:
  • C++: 
    // Two pointers

class Solution {
public:
    void convert(vector<int>& arr, string& version){
        while(version.size()){
            int idx  = version.find_first_of(".");
            if(idx != string::npos){
                string number = version.substr(0, idx);
                arr.push_back(stoi(number));
                version.erase(0, idx + 1);
            }
            else{
                arr.push_back(stoi(version));
                version.erase(0, version.size());
            }
        }
    }
    int compareVersion(string version1, string version2) {
        vector<int> v1;
        vector<int> v2;
        convert(v1, version1);
        convert(v2, version2);
        int n = min(v1.size(), v2.size());
        for(int i= 0; i<n; ++i){
            if(v1[i] == v2[i])
                continue;
            else if(v1[i] < v2[i])
                return -1;
            else   
                return 1;
        }
        if(v1.size() == v2.size())
            return 0;
        //if length v2 > v1
        else if(n  == v1.size()){
            for(int i =n; i < v2.size(); ++i){
                if(v2[i] != 0)
                    return -1;
            }
            return 0;
        }
        else {
            for(int i =n; i < v1.size(); ++i){
                if(v1[i] != 0)
                    return 1;
            }
            return 0;
        }
    }
};


// recursion
class Solution {
public:
    int compareVersion(string version1, string version2) {
        if(version1.empty() && version2.empty())
            return 0;
        int n1 = 0, n2 = 0;
        int idx1 = version1.size();
        int idx2 = version2.size();

        if(!version1.empty()){
            idx1  = version1.find_first_of(".");
            if(idx1 == string::npos) idx1 = version1.size();
            n1 = stoi(version1.substr(0, idx1));
        }
        if(!version2.empty()){
            idx2  = version2.find_first_of(".");
            if(idx2 == string::npos) idx2 = version2.size();
            n2 = stoi(version2.substr(0, idx2));
        }
        if(n1 < n2)
            return -1;
        else if(n1 > n2)
            return 1;
        else{
            auto s1 = idx1 ==  version1.size() ? "" : version1.substr(idx1 + 1);
            auto s2 = idx2 ==  version2.size() ? "" : version2.substr(idx2 + 1);
            return compareVersion(s1, s2);
        }
        
    }
};
O(Max(M, N))

  • Space complexity:
O(M + N)

Code​

 
class Solution(object):
def compareVersion(self, version1, version2):
"""
:type version1: str
:type version2: str
:rtype: int
"""
ver1Arr = version1.split(".")
ver2Arr = version2.split(".")
maxVersionLength = max(len(ver1Arr), len(ver2Arr))
if len(ver1Arr) < maxVersionLength:
for i in range(maxVersionLength - len(ver1Arr)):
ver1Arr.append("0")
if len(ver2Arr) < maxVersionLength:
for i in range(maxVersionLength - len(ver2Arr)):
ver2Arr.append("0")

# Assume that 2 versions are the same
res = 0
for i in range(maxVersionLength):
if int(ver1Arr) > int(ver2Arr):
res = 1
break
elif (int(ver1Arr) < int(ver2Arr)):
res = -1
break
else:
continue
return res
 
PHP: 
class Solution {

    /**
     * @param String $version1
     * @param String $version2
     * @return Integer
     */
    function compareVersion($version1, $version2) {
        $v1 = explode(".", $version1);
        $v2 = explode(".", $version2);
        $swap = false;

        // make sure v1 always longer than v2
        if (count($v1) < count($v2)) {
            list($v1,$v2) = [$v2, $v1];
            $swap = true;
        }

        foreach ($v1 as $i => $v) {
            if(!isset($v2[$i])) $v2[$i] = 0; // set v2[i] to 0 as default
            
            if ($v1[$i] > $v2[$i]) return (!$swap) ? 1 : -1;
            if ($v1[$i] < $v2[$i]) return (!$swap) ? -1 : 1;
        }

        return 0;
    }
}
 
Last edited:
Code: 
impl Solution {
    pub fn compare_version(version1: String, version2: String) -> i32 {
        let mut v1split = version1.split('.').peekable();
        let mut v2split = version2.split('.').peekable();

        while let Some(_) = v1split.peek() {
            if let None = v2split.peek() {
                break;
            }

            let fragment1 = v1split.next().unwrap();
            let fragment2 = v2split.next().unwrap();

            let v1: i64 = fragment1.parse().unwrap();
            let v2: i64 = fragment2.parse().unwrap();


            if v1 == v2 {
                continue;
            }

            if v1 < v2 {
                return -1;
            }

            return 1;
        }


        if let Some(_) = v1split.peek() {
            while let Some(_) = v1split.peek() {
                let fragment1 = v1split.next().unwrap();
                let v1: i64 = fragment1.parse().unwrap();

                if (v1 != 0) {
                    return 1;
                }
            }

            return 0;
        }


        if let Some(_) = v2split.peek() {
            while let Some(_) = v2split.peek() {
                let fragment2 = v2split.next().unwrap();
                let v2: i64 = fragment2.parse().unwrap();

                if (v2 != 0) {
                    return -1;
                }
            }

            return 0;
        }

        return 0;
    }
}
 
JavaScript: 
function compareVersion(version1: string, version2: string): number {
    const v1: string[] = version1.split('.');
    const v2: string[] = version2.split('.');
    const maxLength = Math.max(v1.length, v2.length);

    for (let i = 0; i < maxLength; i++) {
        const firstVersion = Number(v1[i]) || 0
        const secondVersion = Number(v2[i]) || 0

        if (firstVersion < secondVersion) return -1
        else if (firstVersion > secondVersion) return 1
    }

    return 0
};
 
Java: 
class Solution {
    public int compareVersion(String version1, String version2) {
        String[] v1 = version1.split("\\.");
        String[] v2 = version2.split("\\.");
        int i=0;
        for(; i<v1.length && i<v2.length;i++){
            if(Integer.valueOf(v1[i])>Integer.valueOf(v2[i])){
                return 1;
            }
            if(Integer.valueOf(v1[i])<Integer.valueOf(v2[i])){
                return -1;
            }
        }
        if(v1.length>v2.length){
            for(;i<v1.length;i++){
                if(Integer.valueOf(v1[i])>0) return 1;      
            }
        }
        else if(v1.length<v2.length){
            for(;i<v2.length;i++){
                if(Integer.valueOf(v2[i])>0) return -1;
            }
        }
        return 0;
    }
}
 
JavaScript: 
var compareVersion = function(version1, version2) {
    const v1 = version1.split('.').map(x => +x);
    const v2 = version2.split('.').map(x => +x);
    const n = Math.min(v1.length, v2.length);
    let i = 0;
    while (i < n) {
        if (v1[i] < v2[i]) return -1;
        if (v1[i] > v2[i]) return 1;

        i++;
    }

    if (i < v1.length) {
        while (i < v1.length) {
            if (v1[i++] > 0) return 1;
        }

        return 0;
    }

    if (i < v2.length) {
        while (i < v2.length) {
            if (v2[i++] > 0) return -1;
        }

        return 0;
    }

    return 0;
};
 
Medium này với medium hôm nọ đúng là trời vực
Python: 
class Solution:
    def compareVersion(self, version1: str, version2: str) -> int:
        arg1, arg2 = version1.split("."), version2.split(".")
        size1, size2 = len(arg1), len(arg2)
        if size1 > size2:
            for i in range(size1-size2):
                arg2.append(0)
        elif size2 > size1:
            for i in range(size2-size1):
                arg1.append(0)
        for idx, strNum1 in enumerate(arg1):
            num1 = int(strNum1)
            num2 = int(arg2[idx])
            if num1 > num2:
                return 1
            elif num2 > num1:
                return -1
        return 0
 
Medium này dễ quá, easy thôi

Time: O(Max(m, n)), Space O(m+n)
Code: 
class Solution {
    public int compareVersion(String version1, String version2) {
        String[] ver1 = version1.split("\\.");
        String[] ver2 = version2.split("\\.");

        // Swap
        boolean swapped = false;
        if (ver1.length > ver2.length) {
            String[] temp = ver2;
            ver2 = ver1;
            ver1 = temp;
            swapped = true;
        }

         for (int i = 0; i < ver1.length; i++) {
            int revision1 = Integer.parseInt(ver1[i]);
            int revision2 = Integer.parseInt(ver2[i]);

            if (revision1 > revision2) return swapped ? -1 : 1;
            else if (revision1 < revision2) return swapped ? 1 : -1;
        }

        for (int i = ver1.length; i < ver2.length; i++) {
            int revision2 = Integer.parseInt(ver2[i]);
            if (revision2 > 0) return swapped ? 1 : -1;
        }

        return 0;
    }
}
 
C#: 
public class Solution
{
    public int CompareVersion(string version1, string version2)
    {
        string[] revisions1 = version1.Split('.');
        string[] revisions2 = version2.Split('.');
        
        int length = Math.Max(revisions1.Length, revisions2.Length);
        for (int i = 0; i < length; i++)
        {
            int v1 = i < revisions1.Length ? GetVal(revisions1[i]) : 0;
            int v2 = i < revisions2.Length ? GetVal(revisions2[i]) : 0;

            if (v1 == v2)
            {
                continue;
            }
            return Math.Sign(v1 - v2);
        }

        return 0;
    }

    private int GetVal(string s)
    {
        int result = 0;
        for (int i = s.Length - 1; 0 <= i; i--)
        {
            result += (s[i] - '0') * Pow(10, (s.Length - i - 1));
        }

        return result;
    }

    private int Pow(int b, int pow)
    {
        int result = 1;
        for (int i = 0; i < pow; i++)
        {
            result *= b;
        }

        return result;
    }
}
 

Similar threads

hatayquelua
thắc mắc Cần kiến thức gì để được nhận thực tập Dev
2 3
Replies
40
Views
1K
thapnhat111
thapnhat111
L
kiến thức 100 ngày tự học CNTT (AI&Data)
Replies
4
Views
246
shazam
shazam
Build Back Better
  • Locked
Bỡn cợt cô giáo lớn tuổi trên TikTok, giới trẻ đang làm gì vậy?
6 7 8
Replies
154
Views
9K
Wind.G
Wind.G
trustnetvn
thảo luận Ríp tồ: Cho các Fan cuồng BTC, ETH
Replies
0
Views
77
trustnetvn
trustnetvn
T
thắc mắc Làm thế nào để tự động hóa việc thiết lập môi trường dev khi khởi động Windows?
Replies
15
Views
774
shazam
shazam

Share this page

Back
Top