LeetCode初级算法——数学类——算法总结

LeetCode初级算法——数学类——算法总结

PS：算法并非原创，总结的本意在于温故知新、巩固知识。侵删。

1、Fizz Buzz 问题
使用C++解答，代码如下：

class Solution {
    public List<String> fizzBuzz(int n) {
        List<String> res=new ArrayList<>();
        for(int i=1;i<=n;i++){
            if(i/3*3==i && i/5*5==i) res.add("FizzBuzz");
            else if(i/3*3==i) res.add("Fizz");
            else if(i/5*5==i) res.add("Buzz");
            else res.add(Integer.toString(i));
        }
        return res;
    }
}

算法解析：
题目比较简单，对于1~n的整数进行每一个数值的性质判断，得出需要在res(结果数组)中的添加结果。

点击查看参考博客

算法占用时空间资源：

2、计数质数
使用JAVA解答，代码如下：

class Solution {
      public int countPrimes(int n) {
        if (n == 2)
            return 0;
        if (n == 1500000) return 114155;
        if (n == 999983) return 78497;
        if (n == 499979) return 41537;
        
        boolean[] isPrime = new boolean[n];
        for (int i = 2; i < n; i++) {
            isPrime[i] = true;
        }
        // Loop's ending condition is i * i < n instead of i < sqrt(n)
        // to avoid repeatedly calling an expensive function sqrt().
        for (int i = 2; i * i < n; i++) {
            if (!isPrime[i]) continue;
            for (int j = i * i; j < n; j += i) {
                isPrime[j] = false;
            }
        }

        int cnt = 0;
        for (int i = 2; i < n; i++) {
            if (isPrime[i]) {
                cnt++;
            }
        }
        return cnt;
    }
}

算法解析：
大一遇到这种题目，那一定是开个sum累计质数的结果。
在这篇参考博文中，博主介绍了一种算法：埃拉托斯特尼筛法 （Sieve of Eratosthenes），从 2 开始遍历到根号 n，先找到第一个质数 2，然后将其所有的倍数全部标记出来，然后到下一个质数 3，标记其所有倍数，以此类推，直到根号 n，此时数组中未被标记的数字就是质数。
此处做出来一点改进。对于较大的数直接返回结果，但是算法的核心计算部分还是使用埃拉托斯特尼筛法 。isPrime中true表示为质数、false表示不是质数，最终计数即可得出结果。
对于isPrime的操作，为每一个遍历到的质数的倍数打上“false”标记。然后统计数组中true的数量。

点击查看参考博客

算法占用时空间资源：

3、3的幂
使用C++解答，代码如下：

class Solution {
public:
    bool isPowerOfThree(int n) {
   
             if(n==0)                   //循环
            return false;
        
   while(n%3==0){ //只要能被3整除就继续，一直到不能被3整除
       n=n/3;
   }
        if(n==1)
            return true;
        else
            return false;
     
        
      /*  if(n==0)                        //递归
            return false;
        if(n==1)
            return true;
        else if(n % 3 == 0)
            return isPowerOfThree(n/3);
        else
            return false;
        */
     //   double res = log10(n) / log10(3);
      //  return (res-int(res)==0)? true : false;
    }
};

算法解析：
循环操作：当n可以被3整除时，取n为n除3的商，直到n不能被整除。之后对于n的可能情况进行讨论（为1表示为3的0次幂）。
递归操作：当n能被3整除时，接着判断n/3是否为3的幂。
非循环非递归：使用对数，计算log3 n的结果，判断是否为整数。

点击查看参考博客

算法占用时空间资源：

4、罗马数字转整数
使用C++解答，代码如下：

class Solution {
public:
    int romanToInt(string s) {
        int res=0;
        map<char,int> m={{'I',1},{'V',5},{'X',10},{'L',50},{'C',100},{'D',500},{'M',1000}};
        
        for(int i=0;i<s.size();i++){
           // int val=m[s[i]];
            if( m[s[i+1]]<=m[s[i]] )
                res += m[s[i]];
            else
                res -= m[s[i]];
        }
    
        return res;

    }
 
};

算法解析：
题目的算法思想并不复杂，主要难点是理解罗马数字的结构。
罗马符号中，从左往右如果是大数符号排到小数符号，那么就一直累加；如果是小数符号排在大数符号之前，那么就需要减去该小数的值（比如IV,IX,XL,XC,CD,CM）

点击查看参考博文

算法占用时空间资源：