LeetCode刷题记录（第六天）

Self Dividing Numbers

关于昨天题目遗留的问题，原谅我还是没有学会，答案中给了四种方法，虽然意思都理解的差不多，但是答案的代码给的c++版，看完以后还是一脸懵逼，不知道昨天为什么出来一道难度hard的题目，我这种小白easy都吃力，竟然找死写一道只有37%人写出解决方案的难题。。。。不过确实是锻炼脑子，已经死了一半的脑细胞了。。。。今天美好的周六，在公司加了一天的班，晚上竟然还做错了车出了五环。。。。。唉，还是做一道easy的题目安慰一下自己。

原题目：

A self-dividing number is a number that is divisible by every digit it contains.

For example, 128 is a self-dividing number because 128 % 1 == 0, 128 % 2 == 0, and 128 % 8 == 0.

Also, a self-dividing number is not allowed to contain the digit zero.

Given a lower and upper number bound, output a list of every possible self dividing number, including the bounds if possible.

事例：

Example 1:

Input: 
left = 1, right = 22
Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]

Note:

The boundaries of each input argument are  1 <= left <= right <= 10000.

翻译后：

一个自划分数是一个数字，是由它所包含的每个数字整除。

例如，128是自分割数，因为128 % 1 == 0，128 % 2 == 0和128 % 8 == 0。

此外，一个自分数的数字不允许包含数字零。

给定一个较低和较高的数字边界，输出每个可能的自分数的列表，如果可能的话包括边界。

思路：

其实这个题目已经把需要计算的方法说的很清楚了，所以我的思路就是和题目一样。

1、首先遍历范围内所有的整数；

2、然后计算每个整数是否符合题目要求；

    2.1、当然，这样分很多中情况，比如需要知道它是几位数字，数字中有0怎么办。

以下是我自己编写的代码：

package com.mianshi.suanfa.SelfDividingNumbers;

import java.util.LinkedList;
import java.util.List;

/**
 * Created by macbook_xu on 2018/3/24.
 */
public class Solution {
    public static List<Integer> selfDividingNumbers(int left, int right) {
        List<Integer> list = new LinkedList<Integer>();

        for (int i = left ; i <= right ; i++){
            if (String.valueOf(i).length()==1){
                list.add(i);
            }else if (String.valueOf(i).length()==2 && i%10!=0){
                if (i%(i/10)==0 && i%(i%10)==0){
                    list.add(i);
                }
            }else if (String.valueOf(i).length()==3 && i%10!=0 && i%100>10){
                if (i%(i/100)==0 && i%((i%100)/10)==0 && i%(i%10)==0){
                    list.add(i);
                }
            }else if (String.valueOf(i).length()==4 && i%10!=0 && i%100>10 && i%1000>100){
                if (i%(i/1000)==0 && i%((i%1000)/100)==0 && i%((i%100)/10)==0 && i%(i%10)==0){
                    list.add(i);
                }
            }
        }

        return list;
    }

    public static void main(String[] args) {
        System.out.println(selfDividingNumbers(1,9999));
    }
}

不要嘲笑我代码的复杂。。。。毕竟我的思路限制了代码的实现。。。但是应该所有人都可以理解我的代码，非常的直观，嘿嘿。

在多次运行而且实验到题目给的边界范围后，多次的修改，终于使用于1-9999了。但说实话，这是最笨的办法了。

class Solution {
    public List<Integer> selfDividingNumbers(int left, int right) {
        List<Integer> ans = new ArrayList();
        for (int n = left; n <= right; ++n) {
            if (selfDividing(n)) ans.add(n);
        }
        return ans;
    }
    public boolean selfDividing(int n) {
        for (char c: String.valueOf(n).toCharArray()) {
            if (c == '0' || (n % (c - '0') > 0))
                return false;
        }
        return true;
    }
}

Complexity Analysis

• Time Complexity: $O(D)$, where $D$ is the number of integers in the range $[L,R]$, and assuming $\log (R)$ is bounded. (In general, the complexity would be $O(D\log R)$.)

• Space Complexity: $O(D)$, the length of the answer.

这是答案中的第一种方法，非常简单的排除了所有的错误情况和不是自分割数字的情况，它把不符合的筛选出来，然后剩下的就是符合的，而且筛选不符合的逻辑，明显比我写的筛选符合的逻辑要清晰简单的多,从时间和空间复杂度上来看，效率也非常高。

class Solution {
    public List<Integer> selfDividingNumbers(int left, int right) {
        List<Integer> list = new ArrayList<>();
        for (int i = left; i <= right; i++) {
            int j = i;
            for (; j > 0; j /= 10) {
                if ((j % 10 == 0) || (i % (j % 10) != 0)) break;
            }
            if (j == 0) list.add(i); 
        }
        return list;
    }
}

还有很多的大神使用这样的方法，但是通过代码不并不是很懂，如果哪位大神知道，可以留言教教我吗？

今天就先做一道了，学到了换个角度或逻辑去看问题，去寻找解决的方案，可能会有更好的结果。明天会继续做题，并且因为明天是周末，我会把这周的题目代码放到GitHub上面，附带文件讲解，需要的小伙伴明天可以去下载。