小编Fie*_*nix的帖子

作为NetBeans的狂热用户,我在引入新变量时不断获得拆分变量声明和赋值的建议.作为一个超级快速的例子,让我们采用这个Java系列:

String someInput = JOptionPane.showInputDialog(null, "- Enter something: "); 

与:

String someInput;
someInput = JOptionPane.showInputDialog(null, "- Enter something: "); 

NetBeans似乎更喜欢后者(但我不知道其他IDE).虽然它显然有两种方式,但如果有的话,这将被视为"良好做法"？或者纯粹是个人喜好？

(显然,拆分这两个意味着你可以只合并为一个额外的一条线,但那就是重点.)

我有一个带有表格的网页,只有当我点击"检查元素"时才会显示该表格,并且通过"查看源"页面看不到.该表只包含两行,每行包含几个单元格,看起来类似于:

<table class="datadisplaytable">
<tbody>
<tr>
<td class="dddefault">16759</td>
<td class="dddefault">MATH</td>
<td class="dddefault">123</td>
<td class="dddefault">001</td>
<td class="dddefault">Calculus</td>
<td class="dddefault"></td>
<td class="dddead"></td>
<td class="dddead"></td>
</tr>
<tr>
<td class="dddefault">16449</td>
<td class="dddefault">PHY</td>
<td class="dddefault">456</td>
<td class="dddefault">002</td>
<td class="dddefault">Physics</td>
<td class="dddefault"></td>
<td class="dddead"></td>
<td class="dddead"></td>
</tr>
</tbody>
</table>

我要做的是迭代行并返回每个单元格中包含的文本.我似乎无法用Selenium做到这一点.元素不包含ID,我不知道如何获得它们.我不太熟悉使用xpath等.

这是一个调试尝试,返回一个TypeError:

def check_grades(self):
    table = []
    for i in self.driver.find_element_by_class_name("dddefault"):
        table.append(i)
    print(table)

从行中获取文本的简单方法是什么？

我最近为这个LL(1)语法编写了一个递归下降解析器(它生成了一小部分XML):

document ::= element EOF
element ::= < elementPrefix
elementPrefix ::= NAME attribute elementSuffix
attribute ::= NAME = STRING attribute
attribute ::= EPSILON
elementSuffix ::= > elementOrData endTag
elementSuffix ::= />
elementOrData ::= < elementPrefix elementOrData
elementOrData ::= DATA elementOrData
elementOrData ::= EPSILON
endTag ::= </ NAME > 

我已经从这个简单的EBNF语法将语法转换为LL(1):

document  ::=  element
element   ::=  start_tag (element | DATA)* end_tag | empty_tag
start_tag ::=  < NAME attribute* >
end_tag   ::=  </ NAME >
empty_tag ::=  < NAME attribute* />
attribute ::= …

不知道我在这里缺少什么.尝试通过让用户点击"旋转"按钮来使行星(即球体)旋转,但似乎无法弄明白.我确实有以下段通过用户与鼠标的交互来旋转球体:

    document.onmousemove = function() {
        if (!mouseDown) {
            return;
        }
        var newX = event.clientX;
        var newY = event.clientY;

        var deltaX = newX - lastMouseX
        var newRotationMatrix = mat4.create();
        mat4.identity(newRotationMatrix);
        mat4.rotate(newRotationMatrix, degToRad(deltaX / 10), [0, 1, 0]);

        var deltaY = newY - lastMouseY;
        mat4.rotate(newRotationMatrix, degToRad(deltaY / 10), [1, 0, 0]);

        mat4.multiply(newRotationMatrix, planetRotationMatrix, planetRotationMatrix);

        lastMouseX = newX
        lastMouseY = newY;
}

这个工作正常,但我也希望在用户点击按钮后让行星自动旋转.这是我的onLoad功能:

    window.onload = function onLoad() {
        canvas = document.getElementById("gl-canvas");
        initGL(canvas);
        initShaders();
        initBuffers();
        initTexture();
        initEvtHandlers();

        gl.clearColor(0.0, 0.0, 0.0, 1.0);
        gl.enable(gl.DEPTH_TEST); …

我最近使用两种数据结构初步比较了Dijkstra算法的运行时间,基于Java的PriorityQueue(基于二进制堆,如果我没有弄错的话)和Fibonacci堆.我使用Java的currentTimeMillis()来进行计算.我最终得到的结果非常有趣.这是我的一个测试用例的输出:

Running Dijkstra's with 8 nodes and 27 links
- Execution time with binary heap: 1 miliseconds
- Execution time with Fibonacci heap: 4 miliseconds

不可否认,我目前在数据集方面很缺乏,上面的图表是我最大的(我计划尽快制作).但这有什么意义吗？我一直认为Fibonacci堆比其他数据结构更快,因为与其他数据结构相比,它们的运行时间分摊了.我不确定这个3毫秒差异来自哪里.(我在Intel Core Ivy Bridge i7-3630M处理器上运行它,如果有帮助的话.)

注意:我偶然发现了这个可能解释这个问题的线程,尽管我仍然不清楚为什么Fibonacci堆版本需要更长的时间.根据该线程,可能是因为我的图形不够密集,因此reduce-Key操作的数量不足以使Fibonacci堆的性能真正发光.这是唯一合理的结论,还是我还缺少其他的东西？

为简单起见，假设我有一个ArrayList其索引正好包含一位整数。例如：

6 4 5 6 0 6 3 4 1 6 1 6 0 6 8 3

I would like to filter out all occurrences of the sublist 6 0 6, such that the new list becomes:

6 4 5 3 4 1 6 1 8 3

Is there any way of doing this? Using ListIterator doesn't seem to work for me, because I have to consider three consecutive elements collectively and I'm honestly not sure how …

在Glassdoor评论中遇到了这个问题,并认为它很有趣.

给定一个由4位数组成的整数,我们需要以24小时格式最大化它.例如,4372应该返回23:47形式的字符串,这是可以从给定整数获得的最大24小时值.假设给定的整数总是包含4位数.

这是我写的一个不完整的方法试图解决它:

private static String maximize24Hour(int digits) {
    if (digits == 0)
        return "00:00";
    if (digits < 0)
        return null;

    ArrayList<Integer> list = new ArrayList<>();
    do {
        list.add(digits % 10);
        digits /= 10;
    } while (digits != 0);

    // Extra processing needs to be done here. Haven't figured it out. 

    StringBuilder buf = new StringBuilder();
    for (Integer d : list) {
        buf.append(d);
    }

    String result = buf.toString();
    String hours = result.substring(0, 2);
    String minutes = result.substring(2, result.length()); …

在C#6.0中,Microsoft引入了以lambda表达式形式编写方法的能力(实际上,它介于函数块和纯lambda表达式之间;我不确定它是否真的是一个lambda表达式).通常,这就是我编写方法的方法:

private static int Add(int x, int y) { 
    return x + y; 
}

但是,从C#6.0开始,可以重写相同的方法:

private static int Add(int x, int y) => x + y; 

我不明白的是,为什么我会使用后者来支持前者呢？它是纯粹时尚还是在某些情况下,取消功能块实际上是有益的？就可读性而言,对我而言,第二种形式看起来有点不同寻常.我可以更好地与第一个相关联.

我在其他地方遇到过这段代码.它只是添加给定数字中的所有数字:

def sumDigits(n):
    sum = 0
    while n > 0:
        sum += n % 10
        n //= 10
    return sum

问题是,我根本没有得到它背后的逻辑.特别是,我没有完全得到循环的作用:

   while n > 0:
        sum += n % 10  # Why n % 10?
        n //= 10       # Again, not sure why we divide the number by 10

有人可以给我一个算法如何工作的例子吗？

谢谢!

这可能是最愚蠢的问题,但我知道Java中的字符串是不可变的.但是,请考虑扫描典型文件的此代码段:

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    String line;
    while ((line = br.readLine()) != null) {
      // The value of line appears to be reset after each iteration 
    }
}

为什么line这里没有保留其在扫描过程中的价值？这与readLine()方法本身有关吗？我承认我还没有看到该方法是如何实现的,所以我不确定它是如何工作的.