小编ela*_*dan的帖子

我的女朋友在接受采访时得到了这个问题,我非常喜欢它,我以为我会分享它......写一个接收字典的算法(字数组).数组按字典顺序排序,但abc顺序可以是任何内容.例如,它可以是z,y,x,..,c,b,a.或者它可能完全搞砸了:d,g,w,y,......它甚至不需要包含所有的abc字母,最后它根本不必是字母.它可以是形成字符串的任何符号.例如,它可以由5,？,!,@,？组成......你明白了.由您的算法决定发现字母是什么(简单部分).

算法应返回符号的正确词典顺序.

注意事项/需要考虑的事项:1.对于给定的字典,您是否总能发现所有字母的完整顺序？考虑一个只有1个单词,多于1个符号的字典...... 2.你不能认为字典是没有错误的.该算法应确定字典是否包含矛盾并输出存在错误.3.提示:想一个好的数据结构来表示你在符号之间发现的关系.这应该使问题更容易.

我明天可能会发布我的解决方案.我绝不会声称它是最有效的.我想先看看其他人的想法.希望你喜欢这个问题

PS我认为发布解决方案的最佳格式是使用伪代码,但我将此留待您考虑

我有一个算法将拜耳图像通道转换为RGB.在我的实现中,我有一个嵌套for循环,它遍历拜耳通道,从拜耳索引计算rgb索引,然后从拜耳通道设置该像素的值.这里要注意的主要事实是每个像素可以独立于其他像素计算(不依赖于先前的计算),因此该算法是并行化的自然候选者.但是,计算依赖于某些预设数组,所有线程将在同一时间访问但不会更改.

然而,当我尝试将主要for与MS 并行化时,我的cuncurrency::parallel_for性能没有提升.事实上,对于在4核CPU上运行的大小为3264X2540的输入,非并行化版本在~34ms内运行,并行化版本运行在~69ms(平均超过10次运行).我确认该操作确实是并行化的(为该任务创建了3个新线程).

使用英特尔的编译器提供tbb::parallel_for了接近完全的结果.为了比较,我开始使用这个算法实现,C#其中我也使用了parallel_for循环,在那里我遇到了接近X4的性能提升(我选择了C++因为这个特定任务C++即使使用单个核心也更快).

有什么想法阻止我的代码很好地并行化？

我的代码:

template<typename T>
void static ConvertBayerToRgbImageAsIs(T* BayerChannel, T* RgbChannel, int Width, int Height, ColorSpace ColorSpace)
{
        //Translates index offset in Bayer image to channel offset in RGB image
        int offsets[4];
        //calculate offsets according to color space
        switch (ColorSpace)
        {
        case ColorSpace::BGGR:
            offsets[0] = 2;
            offsets[1] = 1;
            offsets[2] = 1;
            offsets[3] = 0;
            break;
        ...other color spaces
        }
        memset(RgbChannel, …

我知道我可以通过生成代码轻松地回答这个问题并查看它是否编译.但由于我找不到类似的问题,我认为这是值得分享的知识.假设我正在为MyClass重载+运算符.我可以多次超载吗？不同类型的不同过载.像这样:

class MyClass{
...
inline const MyClass operator+(const MyClass &addend) const {
    cout<<"Adding MyClass+MyClass"<<endl;
    ...//Code for adding MyClass with MyClass
}
inline const MyClass operator+(const int &addend) const {
    cout<<"Adding MyClass+int"<<endl;
    ...//Code for adding MyClass with int
}
...
};
int main(){
    MyClass c1;
    MyClass c2;
    MyClass c3 = c1 + c2; 
    MyClass c4 = c1 + 5;
}
/*Output should be:
  Adding MyClass+MyClass
  Adding MyClass+in*/

我想这样做的原因是我正在构建一个我希望尽可能优化的类.性能是我最关心的问题.因此,在操作员+重载功能内部铸造和使用开关盒不是一种选择.我注意到,我把内插的重载都做了.让我们假设编译器确实内联我的重载,然后在编译时预先确定哪个代码将运行,并且我将调用保存到一个函数(通过内联)+一个复杂的开关案例场景(实际上,将会有+运算符的5+重载,但我仍然能够使用基本算术运算符轻松编写读取代码.那么,我会得到理想的行为吗？

有没有理由避免rest-assured在非测试环境中使用？库为创建和解析请求提供的语法非常紧凑,仅在测试中使用它似乎是浪费.哪种问题引起了疑问,为什么它仅仅作为测试工具？

我正在构建一个使用SSE内在函数的类层次结构,因此该类的一些成员需要16字节对齐.对于我可以使用的堆栈实例__declspec(align(#)),如下所示:

typedef __declspec(align(16)) float Vector[4];
class MyClass{
...
private:
Vector v;
};

现在,因为__declspec(align(#))是一个编译指令,下面的代码可能会导致堆上的未对齐的Vector实例:

MyClass *myclass = new MyClass;

这也是,我知道我可以通过重载新的和删除操作符来轻松解决使用_aligned_malloc和_aligned_free相应的问题.像这样:

//inside MyClass:
public:
void* operator new (size_t size) throw (std::bad_alloc){
    void * p = _aligned_malloc(size, 16);
    if (p == 0)  throw std::bad_alloc()
    return p; 
}

void operator delete (void *p){
    MyClass* pc = static_cast<MyClass*>(p); 
    _aligned_free(p);
}
...

到目前为止一切都很好..但这是我的问题.请考虑以下代码:

class NotMyClass{ //Not my code, which I have little or no …

我知道有一些方法可以防止用户使用new和delete运算符来阻止在堆上创建类.我正试图做相反的事情.我有一个类,我想阻止用户在堆栈上创建它的实例,并且只有使用new运算符发起的实例才会编译.更具体地说,我希望以下代码在编译期间收到错误:

MyClass c1; //compilation error

MyClass* c1 = new MyClass(); //compiles okay

通过搜索网络,我发现了如何做到这一点的建议:

class MyClass {
public:
    MyClass();
private:
    void destroy() const { delete this; }

...

private:
    ~MyClass();
};

int main(int argc,char** argv)
{
    MyClass myclass; // <--- error, private destructor called here !!!

    MyClass* myclass_ptr = new MyClass;
    myclass_ptr->destroy();
}

我不明白为什么这应该工作.为什么在创建实例时会调用析构函数MyClass？

我正在为我们的驾驶员团队建立一个硬件模拟器.现在,模拟器分为2个模块:第一个模块在驱动程序内部运行,在内核模式下运行,这是驱动程序和HW-Simulator之间的主要接口.第二个模块是一个可执行的用户模式代码,它为模拟器生成数据并通过调用将其传送到模拟器DeviceIOControl(在Windows API下)

我的需求是:我希望能够在内核模式下执行用户模式可执行文件.我需要能够以相对便携的方式做到这一点.目前我只在Windows上运行,但这应该很快就会改变.此外,我需要能够通过它的stdin管道与用户模式代码进行通信,以便重新配置它并最终关闭它.

我发现了这一点: 从内核空间执行用户空间函数

但它只与linux内核相关.有更便携的替代方案吗？或Windows替代？

我可以通过简单地使用ShellExecute/RunAs API函数在Windows中执行此操作吗？

注意:我们知道从内核空间调用用户模式代码所涉及的安全风险.但由于这只是用作测试环境而不会达到我们的发布代码,因此我们并不关心.

在SSE3中,PALIGNR指令执行以下操作:

PALIGNR将目标操作数(第一个操作数)和源操作数(第二个操作数)连接成一个中间复合,将复合体以字节粒度向右移动一个常量立即数,并将右对齐结果提取到目标中.

我目前正在移植我的SSE4代码以使用AVX2指令并使用256位寄存器而不是128位寄存器.天真地,我相信内在函数_mm256_alignr_epi8(VPALIGNR)执行的操作与_mm_alignr_epi8仅256位寄存器相同.但遗憾的是,事实并非如此.实际上,_mm256_alignr_epi8将256位寄存器视为2个128位寄存器,并在两个相邻的128位寄存器上执行2次"对齐"操作.一次有效地执行与_mm_alignr_epi82个寄存器相同的操作.这里最清楚地说明了:_mm256_alignr_epi8

目前我的解决方案是_mm_alignr_epi8通过将ymm(256位)寄存器分成两个xmm(128位)寄存器(高和低)来继续使用,如下所示:

__m128i xmm_ymm1_hi = _mm256_extractf128_si256(ymm1, 0);
__m128i xmm_ymm1_lo = _mm256_extractf128_si256(ymm1, 1);
__m128i xmm_ymm2_hi = _mm256_extractf128_si256(ymm2, 0);
__m128i xmm_ymm_aligned_lo = _mm_alignr_epi8(xmm_ymm1_lo, xmm_ymm1_hi, 1);
__m128i xmm_ymm_aligned_hi = _mm_alignr_epi8(xmm_ymm2_hi, xmm_ymm1_lo, 1);
__m256i xmm_ymm_aligned = _mm256_set_m128i(xmm_ymm_aligned_lo, xmm_ymm_aligned_hi);

这有效,但必须有更好的方法,对吧？是否有更多"通用"AVX2指令应该用来获得相同的结果？

我有一个简单的算法,将拜耳图像通道(BGGR,RGGB,GBRG,GRBG)转换为rgb(去马赛克,但没有邻居).在我的实现中,我预先设置了偏移向量,这有助于我将拜耳通道索引转换为相应的rgb通道索引.唯一的问题是我在使用MSVC11的调试模式下获得了可怕的性能.在发布时,对于3264X2540大小的输入,该功能在~60ms内完成.对于调试中的相同输入,该函数在~20,000ms内完成.这超过了X300的差异,因为一些开发人员在调试中运行我的应用程序,这是不可接受的.

我的代码:

void ConvertBayerToRgbImageDemosaic(int* BayerChannel, int* RgbChannel, int Width, int 

Height, ColorSpace ColorSpace)
{
    int rgbOffsets[4]; //translates color location in Bayer block to it's location in RGB block. So R->0, G->1, B->2
    std::vector<int> bayerToRgbOffsets[4]; //the offsets from every color in the Bayer block to (bayer) indices it will be copied to (R,B are copied to all indices, Gr to R and Gb to B).
    //calculate offsets according to color space
    switch (ColorSpace)
    {
    case ColorSpace::BGGR:
            /*
             B G
             G R …

我很难找到(我确信这是一个非常常见的)设计模式来解决以下问题.考虑一下这段代码:

class AA {};
class BB : public AA {};

class A
{
public:
    virtual void foo(AA& aa) = 0;
};

class B : A
{
public:
    void foo(BB& bb){cout<<"B::foo"<<endl;}
};

int main()
{
    B b;
    BB bb;
    b.foo(bb);
}

此代码将无法编译,因为类B不会覆盖纯虚函数'foo'.编译器认为B声明的foo仅作为foo的重载,因为覆盖函数中的输入参数中不允许使用协方差.

现在,我明白了这个的原因.B继承自A的事实意味着它应该能够使用类型AA的参数处理对foo的任何调用,并且前面的代码没有给出任何实现来处理除BB之外的任何参数类型.

当然我可以在B的foo实现中将aa转换为BB,但我正在寻找一种保留类型安全性的解决方案,并且实际上迫使B类的实现者也实现了一个继承自AA的类以便代码编译.在一个理想的世界里,我可以编写一些看起来像这个伪代码的东西:

class A
{
public:
    abstract class AA{}; //indicates that any child of A must implement also child of AA
    abstract void foo(AA& aa);
};

class B : public A
{
public:
    class BB : AA{}; //will not …

是否有API Xposed通过外壳（使用ADB）而不是通过设备的UI 启用了Android中的模块。

当我们需要将模块安装在干净的测试仿真器上时，这一直困扰着自动化。当前，这是我们需要手动执行的唯一步骤。

一个简单的google搜索+ XPosed文档概述并没有产生任何价值。

我对Java的(7)行为感到有些困惑:

假设我有一个ctor,Foo它需要Map<String,String>一个参数.以下代码:

new Foo(ImmutableMap.of());

产生错误错误:

java:找不到适合Foo(com.google.common.collect.ImmutableMap)构造函数的构造函数Foo(java.util.Map)不适用

尝试强制转换为Map<String, String>显式不起作用,因为编译器抱怨类型不可转换.但是,这很好用:

Map<String, String> map = ImmutableMap.of();
new Foo(map);

到底发生了什么事？为什么编译器对待局部变量的方式与函数参数不同？

假设我有一个xml模式,定义命名空间:http://foo.com/mySchema.是否有标准方法来发布模式,以便模式的xml实例只需要定义命名空间而不是xsi:schemaLocation？

例如,如果你看一下imdb的sitemap xml:http://www.imdb.com/sitemap_US_index.xml.gz

xml定义了一个名称空间:http://www.sitemaps.org/schemas/sitemap/0.9,但没有定义schemaLocation.

如果你访问这个URI,那里有2个xsds:"siteindex.xsd"和"sitemap.xsd"

我的问题是:

1. 这是xml标准的一部分吗？每个xml解析器是否"知道"如何从命名空间URI中查找架构？
2. 是否有一个独立的"xsd repo"工具,可以帮助我在我的域下发布xsds,而无需自己设置Web服务器的麻烦.我正在想象某种RESTful API,它允许我使用他们的命名空间来创建PUT新的模式,DELETE现有的模式,当然还有GET新的模式URI