标签: upperbound

STL提供了二进制搜索函数std :: lower_bound和std :: upper_bound,但我倾向于不使用它们,因为我无法记住它们的作用,因为它们的合同对我来说似乎完全不可思议.

只是从查看名称,我猜"lower_bound"可能是"last lower bound"的缩写,
即排序列表中的最后一个元素<=给定的val(如果有的话).
同样地,我猜"upper_bound"可能是"第一个上限"的缩写,
即排序列表中的第一个元素> =给定的val(如果有的话).

但文档说他们做了一些与此截然不同的事情 - 对我来说似乎是倒退和随机的混合.要解释doc:
- lower_bound找到第一个元素> = val
- upper_bound找到第一个元素> val

所以lower_bound根本找不到下限; 它找到了第一个上限!？并且upper_bound找到第一个严格的上限.

这有意义吗？？你怎么记得的？

pxCSS width和height属性接受的最大有效值是多少？

(我目前正在构建一个创建一个非常大的可缩放容器元素的webapp,我想知道实际的限制是什么.)

在文章http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=binarySearch中,作者讨论了二进制搜索.他区分了找到某些东西是真的最低值,以及某些东西是假的最高值.被搜索的数组看起来像:

false false false true true

我很好奇为什么这两个案例不同.为什么你不能找到真实的最低值,然后减去一个找到最高值,这是假的？

Edit2:好的,所以我理解下限和下限.现在,我正在努力理解,当搜索大于或等于查询的最小整数时,为什么我们不能只改变if(mid>query)to if(mid>=query)并让它更低而不是上限.

编辑:这是文章所说的内容:

"现在我们终于找到实现二进制搜索的代码,如本节和前一节所述:

binary_search(lo, hi, p):
   while lo < hi:
      mid = lo + (hi-lo)/2
      if p(mid) == true:
         hi = mid
      else:
         lo = mid+1

   if p(lo) == false:
      complain                // p(x) is false for all x in S!

   return lo         // lo is the least x for which p(x) is true

...

如果我们想要找到p(x)为假的最后一个x,我们将设计(使用与上面类似的基本原理)类似于:

binary_search(lo, hi, p):
   while lo < hi:
      mid = lo + (hi-lo+1)/2 …

如何获得python中提供的值的下一个最小值？它有内置功能吗？

>>>num_list=[1,2,3,4]
>>> min(num_list)
1
>>> max(num_list)
4

如何找到下一个最低到3或下一个最大到2？预期的结果是2和3.

我有一个对象列表排序,我想找到一个对象的第一次出现和最后一次出现.在C++中,我可以轻松地使用std :: equal_range(或者只使用一个lower_bound和一个upper_bound).

例如:

bool mygreater (int i,int j) { return (i>j); }

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};
  std::vector<int> v(myints,myints+8);                         // 10 20 30 30 20 10 10 20
  std::pair<std::vector<int>::iterator,std::vector<int>::iterator> bounds;

  // using default comparison:
  std::sort (v.begin(), v.end());                              // 10 10 10 20 20 20 30 30
  bounds=std::equal_range (v.begin(), v.end(), 20);            //          ^        ^

  // using "mygreater" as comp:
  std::sort (v.begin(), v.end(), mygreater);                   // 30 30 20 20 20 10 10 10
  bounds=std::equal_range (v.begin(), v.end(), 20, mygreater); …

package org.my.java;

public class TestTypeVariable {

    static <T,A extends T> void typeVarType(T t, A a){
        System.out.println(a.getClass());
        System.out.println(t.getClass());
    }

    public static void main(String[] s){
        int i= 1;
        typeVarType("string", i);
    }
}

运行时,以下是输出:

class java.lang.Integer
class java.lang.String

如何才能A成为类型Integer时,它已经被上界来String？

请解释我.

我很困惑哪个更有效率？

由于我们可以直接访问地图,为什么我们需要使用find？

我只需要知道哪种方式更有效.

#include <iostream>
#include <map>
using namespace std;

int main ()
{
  map<char,int> mymap;
  map<char,int>::iterator it;

  mymap['a']=50;
  mymap['b']=100;
  mymap['c']=150;
  mymap['d']=200;

  //one way

  it=mymap.find('b');
  cout << (*it).second <<endl;

  //another way
      cout << mymap['b'] <<endl;

  return 0;
}

提前致谢!:)

string array[]
long lBound, uBound

lBound = LowerBound(array[]) // = 1, empty array value
uBound = UpperBound(array[]) // = 0, empty array value

array[1] = 'Item 1'
array[2] = 'Item 2'
array[3] = 'Item 3'

lBound = LowerBound(array[]) // = 1
uBound = UpperBound(array[]) // = 3

array[3] = '' //removing item 3

lBound = LowerBound(array[]) // = 1, still
uBound = UpperBound(array[]) // = 3, still (but array[3] is nulled?

我认为'array [3]'这行是错误的,但我想我已经读过这应该删除数组单元格了.

删除阵列单元的正确方法是什么？它取决于对象类型吗？(String vs Number vs Object)

要么

可以操纵UpperBound值使其工作吗？ …

我使用Java 8.在我的设计中,有一些简单的类可以模拟值参数,例如FloatParameter或EnumParameter<E>.A具有这些classes(GenericParameter<T>)的通用超类,它实现了参数名称及其默认值.子类实现了特定于它们的其他属性,例如范围FloatParameter.

此外,我想处理参数的类型,无论其具体类型如何.但是我仍然希望以它们是子类型的方式绑定类型GenericParameter<T>.为了做到这一点,我创建了一个方法,如process(Class<? extends GenericParameter<?>> paramType).

现在的问题是,EnumParameter.class 不能被分配给类型的变量Class<? extends GenericParameter<?>>,而FloatParameter.class 可以是.

此外,我列出了类的代码,使其更清晰,可重复:

public class GenericParameter<T> {
    protected String name;
    protected T defaultValue;
}

public class FloatGenericParameter extends GenericParameter<Float> {
    ...
}

public class TypedGenericParameter<T> extends GenericParameter<T> {
    ...
}

Class<? extends GenericParameter<?>> fgpc = FloatGenericParameter.class; // ok
Class<? extends GenericParameter<?>> tgpc = TypedGenericParameter.class; // error: incompatible types: Class<TypedGenericParameter> cannot be converted to …

在 Java 中还有其他替代方法可以实现相同的目标吗？在 C++ 中，我可以使用这些美妙的方法，让我的生活更轻松。在 Java 中也有可能吗？我唯一的目标是编写简单干净且不易出错的代码。