精华内容
下载资源
问答
  • 临近国庆节,自己小圈子微信群伙伴们发了一张图片,是网上流传的字节跳动面试题编码,闲无事就思索了下,发现都不难,都是对基础数学知识考量。先上图吧! 当然40分钟,我也无法把任意题编码完成...

    前言:

    临近国庆节,自己的一个小圈子微信群的伙伴们发了一张图片,是网上流传的字节跳动的面试题编码,闲的无事就思索了下,发现都不难,都是对基础的数学知识的考量。先上图吧!

    当然40分钟,我也无法把任意两题编码完成,只是知道大概的解题思路,唯一能确定的,在面试规定时间内,第二题我是肯定可以在20分钟内编码完成。

    在这里插入图片描述

    正题

    题目一

    在这里插入图片描述

    基础知识就是初中的平面直角坐标系,解析思路:

    • 计算总周长;
    • 将各边长的前后坐标计算出来封装好,第四步要使用;
    • 根据K段值计算出平均分段后的长度;
    • 然后循环K次,根据平均长度依次相加计算等分点的坐标。

    不多说,上代码:

    先定义坐标的Point类

    class Point {
            float x;
            float y;
     
            public Point() {
            }
     
            public Point(float x, float y) {
                this.x = x;
                this.y = y;
            }
     
            public Point(Point point) {
                this(point.x, point.y);
            }
     
            @Override
            public String toString() {
                return "Point, x:" + x + " y:" + y;
            }
        }
    N边形的边封装类
    
    
    class Line {
            Point begin;
            Point end;
            float length;
     
            public Line() {
     
            }
     
            public Line(Point begin, Point end, float length) {
                this.begin = begin;
                this.end = end;
                this.length = length;
            }
        }
    

    现在上实现计算的类

    这段代码第一个版本的时候,在正方形偶数等分的时候,坐标点计算不准确,今晚上看着代码思考了10分钟的样子,稍微改动了下,暂时没有这个bug了。其他的bug,期待大家一起发现,然后修复吧!

    public class Polygon {
     
        /**
         * 计算边的长度
         * 
         * @return
         */
        private static float lineLength(Point a, Point b) {
            float length;
     
            if (a.x == b.x) {
                // 垂直线条
                length = Math.abs(a.y - b.y);
            } else {
                length = Math.abs(a.x - b.x);
            }
     
            return length;
        }
     
        /**
         * 计算 周长
         * 
         * @return
         */
        private static float totalSideLength(Point[] points, Line[] lines) {
            float side = 0;
     
            for (int i = 1; i < points.length; i++) {
                Point prev = points[i - 1];
                Point point = points[i];
     
                float length = lineLength(prev, point);
     
                side += length;
                lines[i - 1] = new Line(prev, point, length);
     
                if (i == points.length - 1) {
                    length = lineLength(point, points[0]);
     
                    side += length;
                    lines[i] = new Line(point, points[0], length);
                }
            }
     
            return side;
        }
     
        public static Point[] division(Point[] points, int divisionNum) {
            Point[] divisionPoint = new Point[divisionNum];
     
            // 计算周长
            Line[] lines = new Line[points.length];
            float side = totalSideLength(points, lines);
     
            // 等分长度
            float divisionLength = side / divisionNum;
     
            int lineIndex = -1;
            float sumLength = 0;
     
            for (int i = 0; i < divisionNum; i++) {
                if (i == 0) {
                    // 第一个等分点直接是起始点坐标
                    divisionPoint[i] = new Point(points[0]);
                    continue;
                }
     
                divisionPoint[i] = new Point();
                float lineLength = divisionLength * i;
     
                while (true) {
                    Line line;
                    if (sumLength < lineLength) {
                        lineIndex++;
                        line = lines[lineIndex];
                        sumLength += line.length;
                    } else
                        line = lines[lineIndex];
     
                    if (sumLength >= lineLength) {
                        float temp = sumLength - lineLength;
     
                        if (line.begin.x == line.end.x) {
                            // begin和end的坐标点垂直
                            divisionPoint[i].x = line.begin.x;
     
                            if (line.end.y > line.begin.y)
                                divisionPoint[i].y = line.end.y - temp;
                            else
                                divisionPoint[i].y = line.end.y + temp;
                        } else {
                            // begin和end的坐标点水平
                            divisionPoint[i].y = line.end.y;
     
                            if (line.end.x > line.begin.x)
                                divisionPoint[i].x = line.end.x - temp;
                            else
                                divisionPoint[i].x = line.end.x + temp;
                        }
                         
                        break;
                    }
                }
            }
     
            return divisionPoint;
        }
     
        private static void print(Point[] points) {
            for (int i = 0; i < points.length; i++) {
                System.out.println("第" + (i + 1) + "等分点, x:" + points[i].x + ",y:" + points[i].y);
            }
        }
     
        public static void main(String[] args) {
            Point[] points = new Point[] { new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 0) };
     
            Point[] divPoints = division(points, 8);
     
            print(divPoints);
        }
    }
    

    题目二

    在这里插入图片描述

    解题思路:

    对应位数的数字相加,永远不会超过18,所以,我们就先把对应位置的和计算出来,然后再反复循环找到大于9的数,向高位进位。

    这个比较简单,只是考察个位数的正整数加法永远不大于18这个细节。

    上代码:

    public class LinkAddition {
        static class NumNode {
            public int num;
            public NumNode next;
     
            public NumNode() {
            }
     
            public NumNode(int num) {
                this.num = num;
            };
     
            public NumNode(int num, NumNode next) {
                this(num);
                this.next = next;
            }
        }
     
        private static int length(NumNode num) {
            int length = 0;
     
            NumNode temp = num;
            while (temp != null) {
                length++;
                temp = temp.next;
            }
     
            return length;
        }
     
        private static NumNode calc(NumNode a, NumNode b, int aLength, int bLength) {
            NumNode aNode = a;
            NumNode bNode = b;
     
            NumNode result = new NumNode();
            NumNode resultNode = result;
     
            // 计算b链表再a中的起始索引
            int aStartIndex = aLength - bLength;
     
            for (int i = 0; i < aLength; i++) {
                if (i >= aStartIndex) {
                    resultNode.num = aNode.num + bNode.num;
                    bNode = bNode.next;
                } else
                    resultNode.num = aNode.num;
     
                aNode = aNode.next;
                if (aNode != null) {
                    resultNode.next = new NumNode();
                    resultNode = resultNode.next;
                }
            }
     
            return result;
        }
     
        public static NumNode addition(NumNode a, NumNode b) {
            NumNode result = null;
     
            // 计算位数
            int aLength = length(a);
            int bLength = length(b);
     
            if (aLength > bLength) {
                result = calc(a, b, aLength, bLength);
            } else {
                result = calc(b, a, bLength, aLength);
            }
     
            boolean isGreater9 = true;
     
            while (isGreater9) {
                isGreater9 = false;
                NumNode node = result;
     
                while (node != null) {
                    // 检查是否有大于9的节点
                    if (node.num > 9) {
                        isGreater9 = true;
                        break;
                    }
     
                    node = node.next;
                }
     
                // 没有大于9且需要进位的节点
                if (!isGreater9)
                    break;
                 
                node = result;
                 
                if (node.num > 9) {
                    // 头节点的内容跟大于9,需要进位
                    result = new NumNode(1, node);
     
                    node.num = node.num - 10;
                }
     
                while (node.next != null) {
                    if (node.next.num > 9) {
                        node.num += 1;
                        node.next.num = node.next.num - 10;
                    }
                    node = node.next;
                }
            }
     
            return result;
        }
     
        private static void print(NumNode num) {
            NumNode node = num;
            while (node != null) {
                System.out.print(node.num);
                node = node.next;
            }
        }
     
        public static void main(String[] args) {
            NumNode a = new NumNode(9);
            a.next = new NumNode(9, new NumNode(9));
     
            NumNode b = new NumNode(9);
            // b.next = new NumNode(9, new NumNode(9));
     
            NumNode result = addition(a, b);
     
            print(result);
        }
    }
    

    题目三

    在这里插入图片描述

    这个我写的第一个版本,只契合类那个举例,然后瞬间就被我推翻类,最后坐下思考类10分钟,把这个按照二维数组的思路解析了。

    先找到最高处,然后就以最高处为一个维度,做循环计算出水量,还是上代码吧:

    public class Water {
        public static int waterNum(int[] steps) {
            int waterNum = 0;
     
            int max = steps[0];
            for (int i = 1; i < steps.length; i++) {
                if (max < steps[i])
                    max = steps[i];
            }
     
            for (int i = 0; i < max; i++) {
                int num = 0, index = 0;
     
                for (int n = 0; n < steps.length; n++) {
                    if (steps[n] - i > 0) {
                        if (num > 0) {
                            waterNum += n - index - 1;
                        }
     
                        num = steps[n] - i;
                        index = n;
                    }
                }
            }
     
            return waterNum;
        }
     
        public static void main(String[] args) {
            int[] steps = new int[] { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 3, 0, 1 };
            int water = waterNum(steps);
     
            System.out.println(water);
        }
    }
    

    总结:

    其实这几题本身的知识点并不难,都是平时用到的,就看怎么转化为代码罢了。

    第一题考察的直角坐标系上怎么计算边长,然后根据均分等长从第一条边挨着走,计算对应的坐标,该知识点在初中就已学过。

    第二题则是考察每位上的正整数加法到底最大能到多少,只要明白了这一点,把每一位上相加后,再统一做进位处理就可以了。

    第三题的代码量是最少的,我的解题思路是二位数组的方式, 也不算难。
    近段时间正值找工作的最佳时间,本人将一些各大厂商的面试题和今年(2020)最新资料的收集,以下是部分资料截图(所有资料均已整合成文档,pdf压缩打包处理)。
    如有有需要的朋友可以点击这里来获取资料,暗号:qf
    在这里插入图片描述

    展开全文
  • 国庆节后,自己小圈子微信群伙伴们发了一张图片,是网上流传的字节跳动面试题编码,闲无事就思索了下,发现都不难,都是对基础数学知识考量。先上图吧! 当然40分钟,我也无法把任意题编码完成,...

    国庆节后,自己的一个小圈子微信群的伙伴们发了一张图片,是网上流传的字节跳动的面试题编码,闲的无事就思索了下,发现都不难,都是对基础的数学知识的考量。先上图吧!

    当然40分钟,我也无法把任意两题编码完成,只是知道大概的解题思路,唯一能确定的,在面试规定时间内,第二题我是肯定可以在20分钟内编码完成。

    字节跳动的三道编码面试题的实现

     

    题目一

    字节跳动的三道编码面试题的实现

     

    基础知识就是初中的平面直角坐标系,解析思路:

    1. 计算总周长;
    2. 将各边长的前后坐标计算出来封装好,第四步要使用;
    3. 根据K段值计算出平均分段后的长度;
    4. 然后循环K次,根据平均长度依次相加计算等分点的坐标。

    不多说,上代码:

    先定义坐标的Point类

    class Point {
     float x;
     float y;
     public Point() {
     }
     public Point(float x, float y) {
     this.x = x;
     this.y = y;
     }
     public Point(Point point) {
     this(point.x, point.y);
     }
     @Override
     public String toString() {
     return "Point, x:" + x + " y:" + y;
     }
     }
    

    N边形的边封装类

    class Line {
     Point begin;
     Point end;
     float length;
     public Line() {
     }
     public Line(Point begin, Point end, float length) {
     this.begin = begin;
     this.end = end;
     this.length = length;
     }
     }
    

    现在上实现计算的类

    这段代码第一个版本的时候,在正方形偶数等分的时候,坐标点计算不准确,今晚上看着代码思考了10分钟的样子,稍微改动了下,暂时没有这个bug了。其他的bug,期待大家一起发现,然后修复吧!

    public class Polygon {
     /**
     * 计算边的长度
     * 
     * @return
     */
     private static float lineLength(Point a, Point b) {
     float length;
     if (a.x == b.x) {
     // 垂直线条
     length = Math.abs(a.y - b.y);
     } else {
     length = Math.abs(a.x - b.x);
     }
     return length;
     }
     /**
     * 计算 周长
     * 
     * @return
     */
     private static float totalSideLength(Point[] points, Line[] lines) {
     float side = 0;
     for (int i = 1; i < points.length; i++) {
     Point prev = points[i - 1];
     Point point = points[i];
     float length = lineLength(prev, point);
     side += length;
     lines[i - 1] = new Line(prev, point, length);
     if (i == points.length - 1) {
     length = lineLength(point, points[0]);
     side += length;
     lines[i] = new Line(point, points[0], length);
     }
     }
     return side;
     }
     public static Point[] division(Point[] points, int divisionNum) {
     Point[] divisionPoint = new Point[divisionNum];
     // 计算周长
     Line[] lines = new Line[points.length];
     float side = totalSideLength(points, lines);
     // 等分长度
     float divisionLength = side / divisionNum;
     int lineIndex = -1;
     float sumLength = 0;
     for (int i = 0; i < divisionNum; i++) {
     if (i == 0) {
     // 第一个等分点直接是起始点坐标
     divisionPoint[i] = new Point(points[0]);
     continue;
     }
     divisionPoint[i] = new Point();
     float lineLength = divisionLength * i;
     while (true) {
     Line line;
     if (sumLength < lineLength) {
     lineIndex++;
     line = lines[lineIndex];
     sumLength += line.length;
     } else
     line = lines[lineIndex];
     if (sumLength >= lineLength) {
     float temp = sumLength - lineLength;
     if (line.begin.x == line.end.x) {
     // begin和end的坐标点垂直
     divisionPoint[i].x = line.begin.x;
     if (line.end.y > line.begin.y)
     divisionPoint[i].y = line.end.y - temp;
     else
     divisionPoint[i].y = line.end.y + temp;
     } else {
     // begin和end的坐标点水平
     divisionPoint[i].y = line.end.y;
     if (line.end.x > line.begin.x)
     divisionPoint[i].x = line.end.x - temp;
     else
     divisionPoint[i].x = line.end.x + temp;
     }
     
     break;
     }
     }
     }
     return divisionPoint;
     }
     private static void print(Point[] points) {
     for (int i = 0; i < points.length; i++) {
     System.out.println("第" + (i + 1) + "等分点, x:" + points[i].x + ",y:" + points[i].y);
     }
     }
     public static void main(String[] args) {
     Point[] points = new Point[] { new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 0) };
     Point[] divPoints = division(points, 8);
     print(divPoints);
     }
    }
    

    题目二

    字节跳动的三道编码面试题的实现

     

    解题思路:

    对应位数的数字相加,永远不会超过18,所以,我们就先把对应位置的和计算出来,然后再反复循环找到大于9的数,向高位进位。

    这个比较简单,只是考察个位数的正整数加法永远不大于18这个细节。

    上代码:

    public class LinkAddition {
     static class NumNode {
     public int num;
     public NumNode next;
     public NumNode() {
     }
     public NumNode(int num) {
     this.num = num;
     };
     public NumNode(int num, NumNode next) {
     this(num);
     this.next = next;
     }
     }
     private static int length(NumNode num) {
     int length = 0;
     NumNode temp = num;
     while (temp != null) {
     length++;
     temp = temp.next;
     }
     return length;
     }
     private static NumNode calc(NumNode a, NumNode b, int aLength, int bLength) {
     NumNode aNode = a;
     NumNode bNode = b;
     NumNode result = new NumNode();
     NumNode resultNode = result;
     // 计算b链表再a中的起始索引
     int aStartIndex = aLength - bLength;
     for (int i = 0; i < aLength; i++) {
     if (i >= aStartIndex) {
     resultNode.num = aNode.num + bNode.num;
     bNode = bNode.next;
     } else
     resultNode.num = aNode.num;
     aNode = aNode.next;
     if (aNode != null) {
     resultNode.next = new NumNode();
     resultNode = resultNode.next;
     }
     }
     return result;
     }
     public static NumNode addition(NumNode a, NumNode b) {
     NumNode result = null;
     // 计算位数
     int aLength = length(a);
     int bLength = length(b);
     if (aLength > bLength) {
     result = calc(a, b, aLength, bLength);
     } else {
     result = calc(b, a, bLength, aLength);
     }
     boolean isGreater9 = true;
     while (isGreater9) {
     isGreater9 = false;
     NumNode node = result;
     while (node != null) {
     // 检查是否有大于9的节点
     if (node.num > 9) {
     isGreater9 = true;
     break;
     }
     node = node.next;
     }
     // 没有大于9且需要进位的节点
     if (!isGreater9)
     break;
     
     node = result;
     
     if (node.num > 9) {
     // 头节点的内容跟大于9,需要进位
     result = new NumNode(1, node);
     node.num = node.num - 10;
     }
     while (node.next != null) {
     if (node.next.num > 9) {
     node.num += 1;
     node.next.num = node.next.num - 10;
     }
     node = node.next;
     }
     }
     return result;
     }
     private static void print(NumNode num) {
     NumNode node = num;
     while (node != null) {
     System.out.print(node.num);
     node = node.next;
     }
     }
     public static void main(String[] args) {
     NumNode a = new NumNode(9);
     a.next = new NumNode(9, new NumNode(9));
     NumNode b = new NumNode(9);
     // b.next = new NumNode(9, new NumNode(9));
     NumNode result = addition(a, b);
     print(result);
     }
    }
    

    题目三

    字节跳动的三道编码面试题的实现

     

    这个我写的第一个版本,只契合类那个举例,然后瞬间就被我推翻类,最后坐下思考类10分钟,把这个按照二维数组的思路解析了。

    先找到最高处,然后就以最高处为一个维度,做循环计算出水量,还是上代码吧:

    public class Water {
     public static int waterNum(int[] steps) {
     int waterNum = 0;
     int max = steps[0];
     for (int i = 1; i < steps.length; i++) {
     if (max < steps[i])
     max = steps[i];
     }
     for (int i = 0; i < max; i++) {
     int num = 0, index = 0;
     for (int n = 0; n < steps.length; n++) {
     if (steps[n] - i > 0) {
     if (num > 0) {
     waterNum += n - index - 1;
     }
     num = steps[n] - i;
     index = n;
     }
     }
     }
     return waterNum;
     }
     public static void main(String[] args) {
     int[] steps = new int[] { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 3, 0, 1 };
     int water = waterNum(steps);
     System.out.println(water);
     }
    }
    

    总结:

    其实这几题本身的知识点并不难,都是平时用到的,就看怎么转化为代码罢了。

    第一题考察的直角坐标系上怎么计算边长,然后根据均分等长从第一条边挨着走,计算对应的坐标,该知识点在初中就已学过。

    第二题则是考察每位上的正整数加法到底最大能到多少,只要明白了这一点,把每一位上相加后,再统一做进位处理就可以了。

    第三题的代码量是最少的,我的解题思路是二位数组的方式, 也不算难。

    展开全文
  • 自己小圈子微信群伙伴们发了一张图片,是网上流传的字节跳动面试题编码,闲无事就思索了下,发现都不难,都是对基础数学知识考量。先上图吧! 当然40分钟,我也无法把任意题编码完成,只是知道...

    自己的一个小圈子微信群的伙伴们发了一张图片,是网上流传的字节跳动的面试题编码,闲的无事就思索了下,发现都不难,都是对基础的数学知识的考量。先上图吧!

    当然40分钟,我也无法把任意两题编码完成,只是知道大概的解题思路,唯一能确定的,在面试规定时间内,第二题我是肯定可以在20分钟内编码完成。

    字节跳动的三道编码面试题的实现

     

    题目一

    字节跳动的三道编码面试题的实现

     

    基础知识就是初中的平面直角坐标系,解析思路:

    1. 计算总周长;
    2. 将各边长的前后坐标计算出来封装好,第四步要使用;
    3. 根据K段值计算出平均分段后的长度;
    4. 然后循环K次,根据平均长度依次相加计算等分点的坐标。

    不多说,上代码:

    先定义坐标的Point类

    class Point {
     float x;
     float y;
     public Point() {
     }
     public Point(float x, float y) {
     this.x = x;
     this.y = y;
     }
     public Point(Point point) {
     this(point.x, point.y);
     }
     @Override
     public String toString() {
     return "Point, x:" + x + " y:" + y;
     }
     }

    N边形的边封装类

    class Line {
     Point begin;
     Point end;
     float length;
     public Line() {
     }
     public Line(Point begin, Point end, float length) {
     this.begin = begin;
     this.end = end;
     this.length = length;
     }
     }

    现在上实现计算的类

    这段代码第一个版本的时候,在正方形偶数等分的时候,坐标点计算不准确,今晚上看着代码思考了10分钟的样子,稍微改动了下,暂时没有这个bug了。其他的bug,期待大家一起发现,然后修复吧!

    public class Polygon {
     /**
     * 计算边的长度
     * 
     * @return
     */
     private static float lineLength(Point a, Point b) {
     float length;
     if (a.x == b.x) {
     // 垂直线条
     length = Math.abs(a.y - b.y);
     } else {
     length = Math.abs(a.x - b.x);
     }
     return length;
     }
     /**
     * 计算 周长
     * 
     * @return
     */
     private static float totalSideLength(Point[] points, Line[] lines) {
     float side = 0;
     for (int i = 1; i < points.length; i++) {
     Point prev = points[i - 1];
     Point point = points[i];
     float length = lineLength(prev, point);
     side += length;
     lines[i - 1] = new Line(prev, point, length);
     if (i == points.length - 1) {
     length = lineLength(point, points[0]);
     side += length;
     lines[i] = new Line(point, points[0], length);
     }
     }
     return side;
     }
     public static Point[] division(Point[] points, int divisionNum) {
     Point[] divisionPoint = new Point[divisionNum];
     // 计算周长
     Line[] lines = new Line[points.length];
     float side = totalSideLength(points, lines);
     // 等分长度
     float divisionLength = side / divisionNum;
     int lineIndex = -1;
     float sumLength = 0;
     for (int i = 0; i < divisionNum; i++) {
     if (i == 0) {
     // 第一个等分点直接是起始点坐标
     divisionPoint[i] = new Point(points[0]);
     continue;
     }
     divisionPoint[i] = new Point();
     float lineLength = divisionLength * i;
     while (true) {
     Line line;
     if (sumLength < lineLength) {
     lineIndex++;
     line = lines[lineIndex];
     sumLength += line.length;
     } else
     line = lines[lineIndex];
     if (sumLength >= lineLength) {
     float temp = sumLength - lineLength;
     if (line.begin.x == line.end.x) {
     // begin和end的坐标点垂直
     divisionPoint[i].x = line.begin.x;
     if (line.end.y > line.begin.y)
     divisionPoint[i].y = line.end.y - temp;
     else
     divisionPoint[i].y = line.end.y + temp;
     } else {
     // begin和end的坐标点水平
     divisionPoint[i].y = line.end.y;
     if (line.end.x > line.begin.x)
     divisionPoint[i].x = line.end.x - temp;
     else
     divisionPoint[i].x = line.end.x + temp;
     }
     
     break;
     }
     }
     }
     return divisionPoint;
     }
     private static void print(Point[] points) {
     for (int i = 0; i < points.length; i++) {
     System.out.println("第" + (i + 1) + "等分点, x:" + points[i].x + ",y:" + points[i].y);
     }
     }
     public static void main(String[] args) {
     Point[] points = new Point[] { new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 0) };
     Point[] divPoints = division(points, 8);
     print(divPoints);
     }
    }

    题目二

    字节跳动的三道编码面试题的实现

     

    解题思路:

    对应位数的数字相加,永远不会超过18,所以,我们就先把对应位置的和计算出来,然后再反复循环找到大于9的数,向高位进位。

    这个比较简单,只是考察个位数的正整数加法永远不大于18这个细节。

    上代码:

    public class LinkAddition {
     static class NumNode {
     public int num;
     public NumNode next;
     public NumNode() {
     }
     public NumNode(int num) {
     this.num = num;
     };
     public NumNode(int num, NumNode next) {
     this(num);
     this.next = next;
     }
     }
     private static int length(NumNode num) {
     int length = 0;
     NumNode temp = num;
     while (temp != null) {
     length++;
     temp = temp.next;
     }
     return length;
     }
     private static NumNode calc(NumNode a, NumNode b, int aLength, int bLength) {
     NumNode aNode = a;
     NumNode bNode = b;
     NumNode result = new NumNode();
     NumNode resultNode = result;
     // 计算b链表再a中的起始索引
     int aStartIndex = aLength - bLength;
     for (int i = 0; i < aLength; i++) {
     if (i >= aStartIndex) {
     resultNode.num = aNode.num + bNode.num;
     bNode = bNode.next;
     } else
     resultNode.num = aNode.num;
     aNode = aNode.next;
     if (aNode != null) {
     resultNode.next = new NumNode();
     resultNode = resultNode.next;
     }
     }
     return result;
     }
     public static NumNode addition(NumNode a, NumNode b) {
     NumNode result = null;
     // 计算位数
     int aLength = length(a);
     int bLength = length(b);
     if (aLength > bLength) {
     result = calc(a, b, aLength, bLength);
     } else {
     result = calc(b, a, bLength, aLength);
     }
     boolean isGreater9 = true;
     while (isGreater9) {
     isGreater9 = false;
     NumNode node = result;
     while (node != null) {
     // 检查是否有大于9的节点
     if (node.num > 9) {
     isGreater9 = true;
     break;
     }
     node = node.next;
     }
     // 没有大于9且需要进位的节点
     if (!isGreater9)
     break;
     
     node = result;
     
     if (node.num > 9) {
     // 头节点的内容跟大于9,需要进位
     result = new NumNode(1, node);
     node.num = node.num - 10;
     }
     while (node.next != null) {
     if (node.next.num > 9) {
     node.num += 1;
     node.next.num = node.next.num - 10;
     }
     node = node.next;
     }
     }
     return result;
     }
     private static void print(NumNode num) {
     NumNode node = num;
     while (node != null) {
     System.out.print(node.num);
     node = node.next;
     }
     }
     public static void main(String[] args) {
     NumNode a = new NumNode(9);
     a.next = new NumNode(9, new NumNode(9));
     NumNode b = new NumNode(9);
     // b.next = new NumNode(9, new NumNode(9));
     NumNode result = addition(a, b);
     print(result);
     }
    }

    题目三

    字节跳动的三道编码面试题的实现

     

    这个我写的第一个版本,只契合类那个举例,然后瞬间就被我推翻类,最后坐下思考类10分钟,把这个按照二维数组的思路解析了。

    先找到最高处,然后就以最高处为一个维度,做循环计算出水量,还是上代码吧:

    public class Water {
     public static int waterNum(int[] steps) {
     int waterNum = 0;
     int max = steps[0];
     for (int i = 1; i < steps.length; i++) {
     if (max < steps[i])
     max = steps[i];
     }
     for (int i = 0; i < max; i++) {
     int num = 0, index = 0;
     for (int n = 0; n < steps.length; n++) {
     if (steps[n] - i > 0) {
     if (num > 0) {
     waterNum += n - index - 1;
     }
     num = steps[n] - i;
     index = n;
     }
     }
     }
     return waterNum;
     }
     public static void main(String[] args) {
     int[] steps = new int[] { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 3, 0, 1 };
     int water = waterNum(steps);
     System.out.println(water);
     }
    }

    总结:

    其实这几题本身的知识点并不难,都是平时用到的,就看怎么转化为代码罢了。

    第一题考察的直角坐标系上怎么计算边长,然后根据均分等长从第一条边挨着走,计算对应的坐标,该知识点在初中就已学过。

    第二题则是考察每位上的正整数加法到底最大能到多少,只要明白了这一点,把每一位上相加后,再统一做进位处理就可以了。

    第三题的代码量是最少的,我的解题思路是二位数组的方式, 也不算难。

    想要了解更多面试真题,关注后私信我【面试】获取更多

    展开全文
  • 当客户端发送请求在网络某个地方停滞时候,服务器端并不会感知到,延迟到一定时间就会发生超时现象,客户端通常会断开连接。而这时候停滞在途中某个请求,又发送服务器了࿰...
  • Java EJB中有、无状态SessionBean的两个例子 两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用...
  • Java EJB中有、无状态SessionBean的两个例子 两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用...
  • LWUIT是j2me中使用广泛UI库。LWUIT提供了ResourceEdit工具打包资源文件。...前两个字节(用j2me中short表示)记录了该资源文件中资源数量。之后部分被划分成了多个资源块,这个资源块数量由前两个

    LWUIT是j2me中使用广泛的UI库。LWUIT提供了ResourceEdit工具打包资源文件。这个资源文件可以包括主题、字体、图片、动画等。在基于LWUIT库的j2me程序启动时,资源文件被读取解析并导入内存的数据结构中。

     

    LWUIT的资源文件的格式是固定的。前两个字节(用j2me中的short表示)记录了该资源文件中的资源数量。之后的部分被划分成了多个资源块,这个资源块的数量由前两个字节决定。在每个资源块中,第一个字节是magic number,记录了该资源的类型。紧跟着的是一个UTF字符串,记录了该资源的名称。UTF字符串后面部分的内容结构则与资源类型有关。

     

    以主题为例,我用ResourceEdit加入一个命名为hello的theme,并在这个theme中,设置了List.bgSelectionColor和Form.bgColor的值。它的二进制结构如下所示:

     

    第一、二字节:00 01;表示这个资源文件中包含了一个资源块。

    第三字节:F2;这是一个magic number;表示这个资源块是主题。

    第四字节:00 05 68 65 6C 6C 6F;这是一个UTF字符串:“hello”;也就是这个theme的名称。

    以上部分是通用的结构;以下部分是主题相关的结构;

    00 02;记录了该主题资源块中一共有2项。

    00 15 73 74 2E 62 67 53 65 6C 65 63 74 69 6F 6E 43 6F 6C 6F 72;这是一个UTF字符串;即List.bgSelectionColor;

    00 00 00 00;记录了这个项对应的值;

    00 0C 46 6F 72 6D 2E 62 67 43 6F 6C 6F 72;这是一个UTF字符串;即Form.bgColor;

    00 00 00 00;记录了这个项对应的值;

     

    这是主题资源文件的结构。LWUIT提供了Resource类读取并解析这个二进制文件并写入LWUIT现有的内存结构中。

     

    使用LWUIT后,内存中资源相关的有两个Hashtable,一个叫resource,一个叫resourceTypes。

    resourceTypes中记录了id---type对;即资源的名称与资源的类型。例如上面的hello和0xF2。

    resource记录了id-Hashtable对;即资源的名称与资源的hashtable。例如上面的hello与它所对应的Hashtable。

    这个Hashtable中记录了attribute与值。

    List.bgSelectionColor-------0x0000

    Form.bgColor-----------------0x0000

    这个Hashtable的构建是在Resource类中的loadTheme方法中完成的,在这个方法中也可以看到主题中的attribute值是固定的。

     

    而前面的两个Hashtable的设置则是在Resource类中的setResource方法中实现的。

     

    以上所有的操作都在一个语句中完成:

    Resources r1 = Resources.open("/javaTheme.res");

    将这些结构中的数据导入主题中则是在另一个语句中实现的:

    UIManager.getInstance().setThemeProps(r1.getTheme(r1.getThemeResourceNames()[0]));

     

    Resource.getThemeResourceNames方法实际上是遍历Hashtable resourceTypes,找到所有主题ID,以String[]的形式返回。

    而Resource.getTheme则根据传入的string,在Hashtable resource中找到对应的Hashtable。

    最后,UIManager的setThemeProps方法将这个记录了Attribute和值的Hashtable注入到主题中去。

     

    在Theme管理中,LWUIT会给构建一个Hashtable,给表中的每个attribute默认一个值。而setThemeProps则是将传入的Hashtable与默认的表比较并修改默认的表。最后,会创建一个style。

     

     

    展开全文
  • <p>FP与FCP这两个指标之间主要区别是:FP是当浏览器开始绘制内容到屏幕上时候,只要在视觉上开始发生变化,无论是什么内容触发视觉变化,在这一刻,这个时间点,叫做FP。...
  • java开源包1

    千次下载 热门讨论 2013-06-28 09:14:34
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包12

    热门讨论 2013-06-28 10:14:45
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • Java资源包01

    2016-08-31 09:16:25
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包101

    2016-07-13 10:11:08
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包11

    热门讨论 2013-06-28 10:10:38
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包6

    热门讨论 2013-06-28 09:48:32
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包10

    热门讨论 2013-06-28 10:06:40
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包8

    热门讨论 2013-06-28 09:55:26
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包9

    热门讨论 2013-06-28 09:58:55
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • java开源包7

    热门讨论 2013-06-28 09:52:16
    使用简便和直截了当,用户只需要加载的图片和调整帧您想要,如位置,时间显示和处理方法帧。 JavaPList类库 Blister Blister是一用于操作苹果二进制PList文件格式Java开源类库(可用于发送数据给iOS应用...
  • Java EJB中有、无状态SessionBean的两个例子 两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用累加器,以对话状态存储起来,创建EJB对象,并将...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
    两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用累加器,以对话状态存储起来,创建EJB对象,并将...
  •  支持静态链接其它编程语言(如C/C++、汇编等)编译生成静态库(.LIB或.OBJ),但仅限于COFF格式,支持cdecl和stdcall种函数调用约定。  使用说明如下:函数声明和调用方法与DLL命令一致;“库文件名”以.lib...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
    两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用累加器,以对话状态存储起来,创建EJB对象,并将...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
    两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用累加器,以对话状态存储起来,创建EJB对象,并将...
  • getHiddenAlphaAnimation : 获取一由完全显示变为不可见透明度渐变动画 getShowAlphaAnimation : 获取一由不可见变为完全显示透明度渐变动画 getLessenScaleAnimation : 获取一缩小动画 ...
  • java源码包

    2015-12-01 16:29:37
    两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象引用,创建EJB对象,计算利息等;在有状态SessionBean中,用累加器,以对话状态存储起来,创建EJB对象,并将...
  • 实例046 比较两个时间戳大小 77 实例047 使用条件运算符判断数字奇偶性 78 实例048 判断用户是否具有后台管理权限 79 实例049 打印随机组合生日祝福语 80 实例050 打印2000~2020年所有闰年 81 实例051 前置...
  • 实例046 比较两个时间戳大小 77 实例047 使用条件运算符判断数字奇偶性 78 实例048 判断用户是否具有后台管理权限 79 实例049 打印随机组合生日祝福语 80 实例050 打印2000~2020年所有闰年 81 实例051 前置...
  • 分享两个学习Linux命令 Linux-command,linux命令搜索引擎 cheat.sh,不仅仅是linux命令,还包括一些语言像java、scala脚本使用 打造高效工作环境 – SHELL 篇 爬虫篇(Python) 爬虫这一块我也没...

空空如也

空空如也

1 2
收藏数 38
精华内容 15
关键字:

解析图片的前两个字节