小编Mat*_*ans的帖子

我在网上遇到了这个问题，我发现了以下函数来检查 BST 是否有效。但是，我不完全理解最大/最小如何从空更改为可以比较的值。所以在下面的函数中：

//Give the recursive function starting values:

 function checkBST(node) {
  // console.log(node.right);
  return isValidBST(node, null, null);
}


 function isValidBST(node, min, max) {
  console.log(min, max);


  if (node === null) {

    return true;
  }

  if ((max !== null && node.val > max) || (min !== null && node.val < min)) {

    return false;
  }

  if (!isValidBST(node.left, min, node.val) || !isValidBST(node.right, node.val, max)) {

    return false;
  }
  return true;
}



var bst = new BinarySearchTree(8);
bst.insert(3);
bst.insert(1);
bst.insert(6);
bst.insert(10);
bst.insert(4);

当您从左侧的最低深度返回时，它会将最低深度的值与其上方的深度进行比较（即输出 …

我想在给定的parent中启动一个带有挂起函数的异步协程CoroutineScope，以生成一个Deferred可以从该范围内的任何协程使用的a。

我希望如果父级的作业被取消，它的作业也被取消，但是如果挂起函数抛出异常，我需要在结果中捕获该异常，Deferred而不取消父级范围中的同级作业。

我这样做的方式效果很好，但我想知道是否有比这更简单、更符合规范的方法：

fun <T> callIt(scope: CoroutineScope, block: suspend () -> T) : Deferred<T> {
    val result = CompletableDeferred<T>()
    scope.launch {
        try {
            result.complete(block())
        } catch (e: Throwable) {
            result.completeExceptionally(e)
        }
    }
    return result
}

我喜欢对挂起异常的处理block显然是我想要的，但我不太高兴构建async一个launch

不起作用的事情：

• 带有异常处理程序的异步作业。 async捕获其异常，但作业仍然失败并取消其父作业。正如 @Rene 评论的： 的文档async说：“如果未能强制执行结构化并发范例，它会取消父作业（或外部范围）。”。

令人惊讶的是，Kotlin 似乎没有提供InputStream和的暂停版本OutputStream。

自己开发并不难，但这并不能为您提供与这些无处不在的 Java 接口中提供的其他代码的默认兼容性。

如果我想在没有适配器的情况下最大化互操作性，我会使用什么来挂起 Kotlin 中的流接口？

给你一个整数 N。你必须找到 N 的最小倍数，它只由数字 0 和 1 组成。由于这个倍数可能很大，所以以字符串的形式返回它。

返回的字符串不应包含前导零。

例如，

对于 N = 55，110 是由数字 0 和 1 组成的最小倍数。对于 N = 2，10 是答案。

我看到了几个相关的问题，但我找不到我的代码的问题。这是我的代码，即使在使用 map 而不是 set 之后，在某些情况下也会给出 TLE。

#define ll long long
int getMod(string s, int A)
{
    int res=0;
    for(int i=0;i<s.length();i++)
    {
        res=res*10+(s[i]-'0');
        res%=A;
    }
    return res;
}
string Solution::multiple(int A) {
    if(A<=1)
    return to_string(A);

    queue<string>q;
    q.push("1");
    set<int>st;
    string s="1";

    while(!q.empty())
    {
        s=q.front();
        q.pop();
        int mod=getMod(s,A);
        if(mod==0)
        {
            return s;
        }
        else if(st.find(mod)==st.end())
        {
            st.insert(mod);
            q.push(s+"0");
            q.push(s+"1");
        } …

我今天在接受采访时被问到以下问题。我给出了 O(nlgn) 解，但我被要求给出 O(n) 解。我无法想出 O(n) 的解决方案。你能帮我吗？

An input array is given like [1,2,4] then every element of it is doubled and 
appended into the array. So the array now looks like [1,2,4,2,4,8].  How 
this array is randomly shuffled. One possible random arrangement is 
[4,8,2,1,2,4].  Now we are given this random shuffled array and we want to
 get original array [1,2,4] in O(n) time.

The original array can be returned in any order. How can I do it?

我开始一箱的优化性能，和我换了Vec一个VecDeque。容器按排序顺序维护元素（它应该相当小，所以我还没有尝试尝试堆）并且偶尔会从中间拆分成两个单独的容器（我还没有尝试过堆的另一个原因）drain.

我希望第二个操作要快得多：我可以复制集合的前半部分，然后简单地旋转并减少原始（现在是第二个）集合的长度。然而，当我跑我#[bench]的测试中，执行上述操作的次数可变数目，（低于百万NS / iters）我观察到的性能下降与VecDeque：

一个可重现的例子（要点）：

#![feature(test)]
extern crate test;

use std::collections::VecDeque;

fn insert_in_sorted_order_vec<E: Ord + Eq>(t: &mut Vec<E>, k: E) {
    match t.binary_search(&k) {
        Ok(i) => t[i] = k,
        Err(i) => t.insert(i, k),
    }
}

fn insert_in_sorted_order_vecdeque<E: Ord + Eq>(t: &mut VecDeque<E>, k: E) {
    match t.binary_search(&k) {
        Ok(i) => …

我是一名计算机科学工程专业的学生，​​我在许多任务中都遇到了这个问题。

我得到了一个大小的数组有价值观然后问了一些问题。

在每个查询中我都会得到两个索引在哪里。

我相信，有一种方法可以回答这个问题如果进行了一些预处理。

我必须这样做。

我已经解决这个问题很多天了，但我根本无法解决。

输入：

listi = [9, 7, 8, 4, 6, 1, 3, 2, 5]

输出：

# m=3
listo = [9, 8, 8, 6, 6, 3, 5]

给定一个由数字组成的随机列表n，我需要找到m连续元素的所有子列表，从子列表中选择最大值并将它们放入一个新列表中。

def convert(listi, m):
    listo = []
    n = len(listi)
    for i in range(n-m+1):
        listo.append(max(listi[i:3+i]))
    return listo

这个实现的时间复杂度是O(m\^{(n-m+1)}，如果很长的话就很糟糕了listi，有没有办法以 的复杂度来实现这个O(n)？