学习内容

CSS实例,LeeCode

学习语言

CSS,HTML,Java
寒假学习CSSHTMLleeCode

CSS

文本框+按钮

知识

主要思路:利用margin使文本框距离窗口边框一个按钮的大小,使得两个容器分开,本质上是两个独立的组件,而不是相互依赖的.

代码

*{
    margin: 0;
    padding: 0;
}
#left{
    height: 100px;
    background-color:aquamarine;
    margin-right: 200px;/*刚好错开一个按钮的位置*/
    z-index: 0;
}
#right{
    height: 100px;
    width: 200px;
    position: absolute;
    right: 0px;
    top: 0px;
    background-color: black;
    z-index: 1;
}

效果图

BUG:

margin塌陷

现象

垂直方向的margin父子会取最大的来,只改变垂直margin不会改变相对位置.

解决方式

土鳖方法

在父上面加一条(越细越好)的线.加一个类似于这个的语句border-top:1px solid red

BFC方法

可以在CSS种加入这些语句来解决.
必须让他们被包裹在有以下语句的父内.
position:absolute;
diplay:inline-block;
overflow:hidden;隐藏溢出部分

兄弟元素垂直方向margin合并

现象

兄弟容器的垂直方向的空间会重叠

解决方式

1.使他们的计算中加入overflow:hidden,找一个父包裹目标实体.
2.通过将两个的值相加来解决,一般不使用BFC

浮动流

概述:

float:

提供一个将实体排序的方法.,类似于流处理的顺序,会将每个实体变成浮动元素,或者说变成一个border

性质

浮动元素会脱离原先的层.

所有产生浮动流的元素,只有块级元素看不到他们,产生了BFC的元素和文本类属性的元素以及文本都能看到浮动元素.

可以通过clear:both删除浮动流,使一个容器变得正常.
要包裹住一个浮动元素的流程:在浮动元素的最后加一个段落标签,在段落标签中加入clear:both,且对于怕

的大小无要求.

LeeCode(Java)

989.数组形式的整数加法

题目:

对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。

给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。

我的代码

class Solution {
    public List<Integer> addToArrayForm(int[] A, int K) {
        ArrayList<Integer> one = new ArrayList<>();
        ArrayList<Integer> two = new ArrayList<>();
        for (int i = A.length-1; i >=0; i--) {
            one.add(A[i]);
        }
        for(;K!=0;K=K/10){
            two.add(K%10);
        }
        int c=0;
        ArrayList<Integer> res=new ArrayList<>();
        for (int i = 0; i < one.size(); i++) {
            int temp=one.get(i)+c;
            c=0;
            if(two.size()>=i+1){
                temp+=two.get(i);
            }
            if(temp>=10){
                c=1;
            }
            res.add(temp%10);
        }
        for(int i=one.size();i<two.size();i++){
            int temp=two.get(i)+c;
            c=0;
            if(temp>=10){
                c=1;
            }
            res.add(temp%10);
        }
        if(c==1){
            res.add(1);
        }
        ArrayList<Integer> result= new ArrayList<>();
        for (int i = res.size()-1; i >=0; i--) {
            result.add(res.get(i));
        }
        return result;
    }
}

优解代码

class Solution {
    public List<Integer> addToArrayForm(int[] A, int K) {
        LinkedList<Integer> res= new LinkedList<>();
        int i=A.length-1;
        while(i>=0 || K>0){
            if(i>=0){
                K+=A[i--];
            }
            res.addFirst(K%10);
            K/=10;
        }
        return res;
    }
}

1.本质上的思路就是利用一个或while来保证两个都能被取到
2.计算的主干为K,从个位开始取K的数值,这也就意味着反着取数组的值
3.两个相加,当数组没有的时候,结果会直接添加K的该位值,而当K值取完的时候,K该位值为0,不影响数组的取值.
3.使用linkedList,便于使用addFirst()方法,避免了最后的取反

学到的地方

1.LinkedList相对来说会比较耗费内存,但是拥有addFirst()方法.
2.List.get()不能作为赋值的受体,需要使用set(Integer index,Integer Integer)方法来赋值.

202.快乐数

题目:

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

我的代码

class Solution {
    public boolean isHappy(int n) {
       var sum=n;
       var flag=true;
       var temp=0;
       while(sum!=1){
           while (sum!=0){
               temp+=Math.pow(sum%10,2.0);
               sum/=10;
           }
           sum=temp;
           temp=0;
           if(sum==4){
               if(flag){
                   flag= false;
               }else{
                   return false;
               }
           }
       }
       return true;
    }
}

1.使用的思路是非快乐数必定会进入一个4开头,4结尾的循环,所以我只需要将4出现两次的结果归于非快乐数,或者,其实当4第一次出现的时候就可以了.
2.这种方法,涉及数学知识,不涉及算法知识,不够好.

优解代码

class Solution {
    public boolean isHappy(int n) {
        int faster=n;
        int slower=n;
        while(faster!=1&&slower!=1){
            faster=getNext(faster);
            faster=getNext(faster);
            slower=getNext(slower);
            if(faster!=1&&faster==slower){
                return false;
            }
        }
       return true;
    }
    private Integer getNext(int n){
        var sum=0;
        while(n!=0){
            sum+=Math.pow(n%10,2.0);
            n/=10;
        }
        return sum;
    }
}

1.主体思想是使用快慢指针,即一个的速度较快,一个的速度较慢,如果他们俩最终能相当,那么就说明他们进入了循环.
2.以后一些关于循环判断的题目都可以使用快慢指针来解决.