小编rua*_*akh的帖子

我了解到 -r 表示递归，这意味着该命令可以在所有子目录中执行。为了确保我理解，我写了下面的两个函数来进行一些测试。我编写以下代码的文件名为 test.sh。在同一个目录中，我有一个名为 subtest 的子目录。在当前目录或子目录中有一个名为 xx.sh 的文件。

#!/bin/bash
function aa {
  if [ ! -r $1 ]
  then
    echo "not exist"
  else
    echo "exist"
  fi
}

function bb {
  if [ -r $1 ]
  then
    echo "exist"
  else
    echo "not exist"
  fi
}

aa xx.sh / bb xx.sh

我发现的结果：

对于 aa 函数，-r如果 xx.sh 在当前目录中，它只会打印“exist”。它不会在子目录中查找 xx.sh。没有-r，当 xx.sh 在当前目录或子目录中时，它将打印“存在”。

对于 bb 函数，使用-r，它只会在当前目录有 xx.sh 时打印“exist”。没有-r，它总是会打印“存在”，即使根本没有 xx.sh （这让我感到惊讶并且没有意义！）。

谁能解释为什么会发生上述结果以及 -r 究竟做了什么？

这样的事情做什么？

static int i;

// wrapped in a big loop
void update_text()
{
    std::stringstream ss; // this gets called again and again
    ++i;
    ss << i;
    text = new_text(ss.str()); // text and new_text are defined elsewhere
    show_text(text); // so is this
}

是用新地址和所有东西在堆栈中创建一个新的ss实例？将sprintf与char数组一起使用会更聪明吗？

我当前有这个代码

SELECT JOB.JobID, A.adID, AR.ARNum
FROM dbo.vEvent AS E, dbo.[vAd] as A, dbo.[vAR] as AR, dbo.JOB_EVENT as JOB
INNER JOIN A ON A.eventID = E.eventID
INNER JOIN AR ON AR.eventID = A.eventID
INNER JOIN JOB ON JOB.EVENT_ID = E.eventID
WHERE year = '' AND season = '' AND month = ''

然而; 当我在SQl服务器中执行它时,我收到此错误.

Msg 208, Level 16, State 1, Line 1
Invalid object name 'A'.

我不明白,因为我的所有变量对我来说都是正确的.

任何帮助,将不胜感激.

有人能告诉我为什么这段代码给我一个编译错误？

public class Main {

    public static void main(String[] args) {
        System.out.println(sum(2, 6.9));
    }

    public static <T extends Number<T>> T sum(T a, T b) {
        T result = a + b;      // compile-error here
        return result;
    }
}

我试图运行这可能但上面的错误消息继续出现.我已经尝试了一切,但似乎没有用.请任何人帮忙!!!

SELECT tblGameResults.MatchNumber,
       Sum(tblPlayerStatistics.Fouls_Made) AS Fouls
FROM tblGameResults 
INNER JOIN tblPlayerStatistics ON tblGameResults.MatchNumber = tblPlayerStatistics.MatchNumber
WHERE (((tblGameResults.Date_Of_Game)=[Date_Of_Game]) 
  AND ((tblGameResults.Place_Of_Game)=[Place_Of_Game]));

我刚开始接受go,我正在审视数据结构.我习惯拥有像listin python或std::vectorin 这样的动态数组C++,但我没有看到类似的东西go.关于动态数组的好处是它具有添加新元素的O(1)时间复杂度,以及用于索引的O(1)时间复杂度.

首先我认为slice是这样,但后来我意识到当我使用append函数时,整个切片被复制,因此它是O(N)操作而不是动态数组中的O(1).

然后我遇到了列表,但这是一个双向链表,这意味着索引是O(N),而不是O(1).

我错过了我正在寻找的数据结构吗？

考虑以下游戏:

• 约翰和彼得同意一个数字n.
• 约翰选择1和n之间的数字x.
• 彼得提出了一系列猜测ķ 1和之间Ñ.对于每个猜测:
  • 如果X/2≤  ķ  ≤2 X,然后彼得获胜.
  • 否则,约翰告诉彼得x是否小于k.

彼得希望以最少的猜测获胜.

有明显的解决方案需要最坏情况的O(log  n)猜测,但是一位朋友告诉我,有一个解决方案具有比这更好的渐近行为.我的朋友对吗？

给定一个正整数n  ? 10 ⁷，我需要找到最小的正整数k，使得 2 ^k的十进制表示以n的十进制表示开头。

因此，例如，如果n  = 12，则k  = 7（因为 2 ⁷  =  12 8）；如果n  = 134，则k  = 27（因为 2 ²⁷  =  134 ,217,728）；如果n  = 82，则k  = 209（因为 2 ²⁰⁹  ?  8.2 3×10 ⁶²）。

（如果不存在这样的k，我需要返回 ?1。）

我什至没有尝试用公式来解决它（我不知道如何解决），并决定通过计算 2 到 1000 的所有幂来解决，将它们放在一个列表中，然后找到开始的数字的索引与 该代码有效，但是...它甚至没有通过系统中的第一个测试。我不知道为什么，因为它适用于上述示例。无论如何，这是代码。

def find_all():
    arr = []
    n = 1
    for i in range(1000):
        arr.append(str(n))
        n = n << 1
    return arr


n …

我正在尝试解决这个问题：

给定一个正整数数组和一个整数Y，您最多可以用较小的值替换Y数组元素。您的目标是让数组以尽可能大的相同值的子集结束。返回这个最大子集的大小。

该数组最初排序递增的顺序，但你并不需要保存该属性。

因此，例如，如果数组是 [10,20,20,30,30,30,40,40,40] 并且Y  = 3，那么结果应该是 6，因为通过替换三个 40 可以得到六个 30与 30 年代。如果数组是 [20,20,20,40,50,50,50,50] 并且Y  = 2，结果应该是 5，因为您可以通过用 20 替换 50 中的两个来获得五个 20。

下面是我的 O(nlogn) 时间复杂度的解决方案。（是这样吗？）我想知道我是否可以进一步优化这个解决方案？

提前致谢。

public class Nails {

    public static int Solutions(int[] A, int Y) {
        int N = A.length;
        TreeMap < Integer, Integer > nailMap = new TreeMap < Integer, Integer > (Collections.reverseOrder());
        for (int i = 0; i < N; i++) {
            if (!nailMap.containsKey(A[i])) {
                nailMap.put(A[i], …

我编写了一个脚本来交织两个文件的内容。脚本是这样的

#!/bin/bash

touch t_10.txt

numer1=$(cat $1 | wc -l)
numer2=$(cat $2 | wc -l)

count=1
while [ $count -le $numer1 -a $count -le $numer2 ]
    do
        head -n $count $1 | tail -n 1 >> merge.txt
        head -n $count $2 | tail -n 1 >> merge.txt
        count=$((count + 1))
done

count=$((count-1))
if [ $count -lt $numer1 ]; then
    rem=$(( $numer1 - $count ))
    tail -n $rem $1 >> merge.txt
else
    rem=$(( $numer2 - $count ))
    tail -n $rem $2 >> …