小编eol*_*old的帖子

我正在努力处理在特定月份(例如,2月)修改的列表文件.以下是几次不成功的尝试:

1)我尝试创建临时文件并在下个月第一次设置时间戳,并在目标月份中第一次设置并在find中使用-newer,如下所示:

find -newer "$from" ! -newer "$to"

这列出了在时间间隔($ from,$ to)中修改的文件,但我希望时间间隔[$ from,$ to)(否则,在下个月的第一秒创建的文件会出现误报) .2月修改的列表文件是额外的问题,因为这需要将其中一个时间戳设置为仍然在2月份的最大时间戳,但是2月份的天数取决于它是否是闰年,这需要额外的检查.

2)如果我使用,ls我在解析时会看到很多复杂因素,因为用户名或组可能包含空格.

有没有一种简单的方法和相对便携的方式(所以它适用于任何月份,无论文件名等)？

我在子程序中传递和读取参数时遇到问题,该子程序预计会有两个数组.

sub two_array_sum { # two_array_sum ( (1 2 3 4), (2, 4, 0, 1) ) -> (3, 6, 3, 5)
  # I would like to use parameters @a and @b as simply as possible
}

# I would like to call two_array_sum here and pass two arrays, @c and @d

我已经看过并尝试过网上的几个例子,但它们都没有为我工作.

我正在为Java中的回合制游戏编写游戏服务器.这些都是事实:

• 游戏的速度很慢,所以客户端需要每8秒发送一次数据,而且数据大部分时间只是一个小的增量更新(几十个字节),除了加入游戏或列表之类的情况可用游戏等
• 服务器必须支持大量的玩家,比方说1000,玩几百个游戏中的一个
• 当玩家转弯时,必须通知同一游戏中的其他玩家移动.游戏中玩家的最大数量约为10

首先,我从我的选项列表中排除了UDP,因为我需要一个可靠的协议,因为在极少数情况下我真的需要发送一些不适合一个数据包的数据,我不想打扰合并数据包和类似的东西,跟踪到达的包裹和其他低级别的东西的顺序.

所以困境在于是使用TCP还是HTTP.

TCP尝试#1

从客户端到服务器的连接(反之亦然)始终打开.这样,当玩家进行移动时,服务器可以容易地通知游戏中的其他玩家进行了移动.使用这种方法困扰我的主要问题是,是否建议甚至可以连续打开1000个连接和套接字？

TCP尝试#2

我想到的替代方案是,用于在客户端的每个请求上建立单独的连接/套接字.客户端将打开连接,将一些小数据发送到服务器并关闭该连接.使用这种方法,我可以有一个固定大小的线程池,比方说10,并在每个线程中单独处理客户端的请求,这样任何时候最多可以打开10个connectinos/socket.但是这种方法有两件事困扰我:

1. 打开/关闭与客户端的连接的昂贵
2. 在游戏中通知其他玩家的方式,因为与他们的联系很可能是关闭的.在这种情况下,每个人都应该"轮询"服务器进行更新,让我们说每一秒.

建立TCP套接字/连接的成本是多少？这是一项昂贵的操作还是仅在几毫秒(或更短)内完成？

HTTP

1. 如果我发送一个新的GET/POST只发送几个字节会有很多开销吗？
2. 我可以同时保持与客户端的1000个HTTP连接,然后使用AJAX或类似的东西来减少开销吗？在这种情况下,1000个同时连接会对带宽/性能造成严重问题吗？

我接受任何形式的建议/意见.

我正在与另外8个人合作开发一个跨平台的C++项目,该项目使用以下库:

• OpenCV库
• 提升C++库

该项目旨在跨平台,因此所有用户都同意不使用特定于平台的代码,并且为了使事情尽可能简单,所有用户都将使用Eclipse作为他们的IDE.但是,有些人将使用Eclipse for Windows,而其他人将使用Eclipse for Linux.

由于项目将托管在SVN上,我们希望避免与共享的不同配置文件(如make文件,eclipse项目文件等)发生冲突.我们还希望通过SVN尽可能多地共享配置文件,以使配置尽可能简单.

假设所有用户都已正确配置系统变量并安装了所需的构建工具(例如make,cmake等),并已正确配置其Eclipse设置(但不是项目特定的设置).

如何配置项目一次以及在存储库中共享哪些配置文件,以便Windows和Linux用户都可以编译它而无需修改从SVN存储库中检索的配置文件？

(我不是在寻找专门针对我提到的那两个库的完整解决方案,所以我将非常感谢一般的逐步解释,这使我能够轻松地添加另一个库.)

我正在寻找一个在Java中工作的高效公式,它计算以下表达式:

(low + high) / 2

用于二进制搜索.到目前为止,我一直在使用"低+(高 - 低)/ 2"和"高 - (高 - 低)/ 2"来避免某些情况下的溢出和下溢,但不是两者都有.现在我正在寻找一种有效的方法,可以用于任何整数(假设整数范围从-MAX_INT - 1到MAX_INT).

更新:结合Jander和Peter G.的答案并进行实验一段时间我得到了中值元素及其近邻的以下公式:

最低中点(等于floor((low + high)/2),例如[2 3] - > 2,[2 4] - > 3,[-3 -2] - > -3)

mid = (low & high) + ((low ^ high) >> 1);

最高中点(等于ceil((low + high)/2),例如[2 3] - > 3,[2 4] - > 3,[-3 -2] - > -2)

low++;
mid = (low & high) + ((low ^ high) >> 1);

中 - 前点(等于 …

好的,我知道提交和回滚之间的区别以及这些操作应该做什么.但是,在使用commit(),rollback()和/或什么都不做的情况下我可以实现相同的行为时,我不确定该怎么做.

例如,假设我有以下代码执行查询而无需写入db:我正在处理与SQLite数据库通信的应用程序.

try {
  doSomeQuery()
  // b) success
} catch (SQLException e) {
  // a) failed (because of exception)
}

或者更有趣的是,请考虑以下代码,它会删除一行:

try {
  if (deleteById(2))
    // a) delete successful (1 row deleted)
  else
    // b) delete unsuccessful (0 row deleted, no errors)
} catch (SQLException e) {
  // c) delete failed (because of an error (possibly due to constraint violation in DB))
}

从语义角度观察,在b)和c)情况下进行提交或回滚会导致相同的行为.

通常,每种情况下都有几种选择(a,b,c):

• 承诺
• 回滚
• 没做什么

选择特定操作是否有任何指导或性能优势？什么是正确的方法？

注意:假设禁用了自动提交.

我需要解决动态凸包算法问题,即保持2D点的凸包,我可以添加和删除点.

天真的做法很明显O(N); 无论何时N添加/删除其中一个点,我们都会从头开始重新计算凸包.但是,我无法承受线性时间,因此我正在寻找一种次线性算法.到目前为止,我已经找到了一堆纸,所有这些都描述了一些具有疯狂时间限制的复杂算法,这需要花费很长时间才能实现.即使是最古老的高效算法,由于Overmars和Leeuween,这O(log^2 N)似乎太复杂了.(像往常一样,这些论文中描述的大多数算法在结构/算法方面都有很多依赖性来自其他参考文献)

我正在寻找更简单,更不一定新颖的东西,在最坏的情况下(例如O(sqrt N))在线性方面表现优于线性.最后,我不介意时间是否摊销.有任何想法吗？

(简单来说,我主要是指不需要超过几百行代码的东西.)

我有一个整数类型,例如long,其值介于Long.MIN_VALUE = 0x80...0(-2 ^ 63)和Long.MAX_VALUE = 0x7f...f(2 ^ 63 - 1)之间.我希望以Long.MAX_VALUE干净有效的方式将~50%碰撞哈希到相同类型的正整数(即介于1和之间).

我的第一次尝试是这样的:

• Math.abs(x) + 1
• (x & Long.MAX_VALUE) + 1

但是那些和类似的方法总是会遇到某些值的问题,即何时x是0/ Long.MIN_VALUE/ Long.MAX_VALUE.当然,天真的解决方案是使用2 if语句,但我正在寻找更清洁/更短/更快的东西.有任何想法吗？

注意:假设我在Java中工作,没有隐式转换为boolean并且定义了shift语义.

当我设计一个通用类时,我经常处于以下设计选择之间的两难境地:

template<class T>
class ClassWithSetter {
 public:
  T x() const; // getter/accessor for x
  void set_x(const T& x);
  ...
};
// vs
template<class T>
class ClassWithProxy {
  struct Proxy {
    Proxy(ClassWithProxy& c /*, (more args) */);
    Proxy& operator=(const T& x);  // allow conversion from T
    operator T() const;  // allow conversion to T
    // we disallow taking the address of the reference/proxy (see reasons below)
    T* operator&() = delete;
    T* operator&() const = delete;
    // more operators to delegate to …

我的团队正在开发一个Android项目,该项目由几个交换数据的Android应用程序组成(在同一部手机上).我们的想法是让几个应用程序收集一些数据并将这些数据发送到主应用程序.这里的主要挑战是在CPU负载和电池使用方面尽可能便宜地进行交换.

据我所知,有两种方法可以实现进程间通信:

1. 意图和活动 - 一项活动捕捉另一项活动的意图
2. 远程方法(通过AIDL)

我想知道在以下场景中哪些更有效:

1. 非常频繁的消息/方法调用,发送/流量非常少(例如只传递一堆基元)
2. 具有大流量块的较不频繁的消息/方法调用(例如,收集数据并定期发送几KB/MB的数据)
3. 交换大数据块的非常频繁的消息/方法调用

无论是在比较方面还是与基准的参考/链接方面,我都将不胜感激.