小编m69*_*g''的帖子

我使用这个名为transit.js的插件来创建一个简单的菜单动画,基本上我有以下菜单,见下图:

打开和关闭菜单的代码如下:

$('.main-header .nav-toggle-button').on('click' , function() {

    // $('.main-header .navigation').toggleClass('show');

    if ($('.main-header .navigation').hasClass('show'))  {
        $('.main-header .navigation').stop().removeClass('show');
        return false;
    }

    $('.main-header .navigation').stop().transition({
          perspective: '1000px',
          rotateY: '180deg',
          duration : 0
        }, function() {
          $(this).addClass('show').stop().transition({ rotateY: '0' });
        });

    return false;

}); 

DEMO HERE,(对不起,小提琴只是没有重现这个问题.)

BUG:正如你所看到的那样,没有动画,菜单消失,现在当页面滚动超过200px+和低于992px宽度时会出现这个错误 ,所以基本上当你点击汉堡包时,菜单会打开一个旋转动画但是当你再次点击汉堡包时,即使从菜单中删除了'show'类,菜单有时也不会关闭.

这是我之外的其中一个错误,在控制台中检查并通过JS代码实际上并没有真正帮助.

我真的很感激,如果有人能指出我在这里做错了什么,因为JS和CSS看起来确实很完美但是使用传输的css转换只是没有按预期工作.

我需要通过仅检查/比较表达式来比较文件系统通配符表达式以查看它们的结果是否重叠.

为了便于举例,我们正在构建一个实用程序,它可以根据文件系统通配符表达式将文件从一个(或多个位置)排序到单独的文件夹中.例如:*.txt进入文件夹a,*.doc进入文件夹b,依此类推.我们支持的通配符是*和？

我希望能够通过分析通配符表达式确定它们是否会冲突/重叠.

例如,如果我有以下表达式:

*.x.y
*.y

它们会冲突(重叠),因为第二个表达式*.y将包含*.xy结果.(例如Axy会匹配两个表达式)

我正在通过使用所有表达式构建树结构来接近这一点,认为如果表达式冲突,构建树的行为将失败.

For example:
*.x
a.b
a.c
b.d

might create a tree like 

         +-*-.-x
         |
start +--+
         |     +-b
         |     |
         +-a-.-+-c
         |
         |
         +-b-.-d

如果我尝试添加模式bx,则树将在*.x路径后成功,从而表示模式已存在.

我正朝着正确的方向前进吗？或者是否有一种已知的攻击方法？

我有网格N×M,其中每个单元格用一种颜色着色.

当玩家点击颜色α网格的任何单元格时,网格最左上角的颜色为β的单元格接收颜色α,但不仅仅是:所有那些通过颜色连接到源的单元格仅使用颜色α或β的路径也接收颜色α.

应仅在水平和垂直方向上考虑单元之间的连接以形成路径.例如,当玩家点击左图中突出显示的单元格时,网格会在右侧接收图形的颜色.游戏的目标是使网格单色化.

输入描述

输入的第一行由2个整数N和M(1≤N≤4,1≤M≤5)组成,它们分别代表网格的行数和列数.下面的N行描述了网格的初始配置,用0到9之间的整数表示每种颜色.输入不包含任何其他行.

输出描述

打印包含单个整数的行,该整数表示播放器必须执行的最小点击次数才能使网格变为单色.

输入样本

1:

4 5
01234
34567
67890
90123

2:

4 5
01234
12345
23456
34567

3:

4 5
00162
30295
45033
01837

输出样本

1:

12

2:

7

3:

10

我正在尝试找回带回溯的解决方案(因为8秒的时间限制和网格的小尺寸).但它超出了时间限制.有些人刚刚在0秒时完成了它.

还有其他算法可以解决这个问题吗？

#include <stdio.h>
#include <string.h>

#define MAX 5
#define INF 999999999

typedef int signed_integer;

signed_integer n,m,mink;
bool vst[MAX][MAX];

signed_integer flood_path[4][2] = {
    {-1,0},
    {1,0},
    {0,1},
    {0,-1}
};

//flood and paint all possible cells... the root is (i,j)
signed_integer flood_and_paint(signed_integer cur_grid[MAX][MAX],signed_integer i, signed_integer j, …

我实现了一些主数据结构是树的算法.我使用一个类来表示一个节点和一个表示树的类.因为节点得到了很多更新,所以我称之为许多setter和getter.

因为我多次听说函数调用很昂贵,所以我想也许如果我使用结构表示节点和树,它会使我的算法在实践中更有效率.

在这样做之前,我决定进行一个小实验,看看是否真的如此.

我创建了一个有一个私有变量,一个setter和一个getter的类.此外,我创建了一个具有一个变量的结构,没有setter/getter,因为我们可以通过调用来更新变量struct.varName.结果如下:

运行次数是我们调用setter/getter的次数.这是实验的代码:

#include <iostream>
#include <fstream>

#define BILLION  1000000000LL

using namespace std;

class foo{
private:
    int a;
public:

    void set(int newA){
        a = newA;
    }
    int get(){
        return a;
    }
};

struct bar{
    int a;
};

timespec startT, endT;

void startTimer(){
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &startT);
}

double endTimer(){
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &endT);
    return endT.tv_sec * BILLION + endT.tv_nsec - (startT.tv_sec * BILLION + startT.tv_nsec);
}


int main() {

    int runs = 10000000;
    int startRun = 10000;
    int step = …

如果我有一个没有负权重的加权无向图,但是可以包含顶点和自循环之间的多个边,我可以毫无问题地运行Dijkstra算法来找到源和目标之间的最小路径,还是存在一个反例？

我的猜测是没有问题,但我想确定.

例如,房间里有6把椅子,有4个女孩和2个男孩.他们可以坐在这把椅子上,有15种独特的方式6!/(4!*2!)=15.

我的问题是找到有效的方法来计算他们选择坐的可能性的位置.按位置我的意思是:

BBGGGG - possible position #1
BGBGGG - possible position #2
BGGBGG - possible position #3
BGGGBG - possible position #4
BGGGGB - possible position #5
GBBGGG - possible position #6
GBGBGG - possible position #7
GBGGBG - possible position #8
GBGGGB - possible position #9
GGBBGG - possible position #10
GGBGBG - possible position #11
GGBGGB - possible position #12
GGGBBG - possible position #13
GGGBGB - possible position #14
GGGGBB - possible position #15

例如,他们选择位置 …

如果我有一个大的int,比如一个uint64_t和一个uint8_t数组,例如:

uint64_t large = 12345678901234567890;
uint8_t small[5];

我想将8个最低有效位复制uint64_t到数组的元素中uint8_t,使用是否安全:

small[3] = large;

或者我应该使用位掩码:

small[3] = large & 255;

即是否有任何情况,其中大型int的其余部分可能以某种方式溢出到数组的其他元素？

最近我设计了一个儿童难题来解决.但是,我想现在最优解决方案.

问题如下:你有这个数字由小方块组成

你必须用更大的方块填充它,并使用下表进行评分:

| Square Size | 1x1 | 2x2 | 3x3 | 4x4 | 5x5 | 6x6 | 7x7 | 8x8 |
|-------------|-----|-----|-----|-----|-----|-----|-----|-----|
| Points      | 0   | 4   | 10  | 20  | 35  | 60  | 84  | 120 |

有很多可能的解决方案来检查它们.其他人建议动态编程,但我不知道如何将数字划分为较小的数字,这些数字放在一起具有相同的最优解.

我想找到一种方法,在合理的时间内找到解决这类问题的最佳方案(比如常规桌面上最多几天).到目前为止,使用猜测算法和一些手动工作找到的最高分是1112.

还可以理解组合子问题的类似问题的解决方案.我不需要写出所有代码.算法的概要或想法就足够了.

注意:可以容纳的最大正方形是8x8,因此不包括较大正方形的分数.

[[1,1,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,1],
 [1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1],
 [1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1],
 [0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0],
 [0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0],
 [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1],
 [0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1],
 [1,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1],
 [1,1,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,0,0,1],
 [1,1,1,0,0,0,0,1,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0],
 [0,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0],
 [0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0],
 [0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0],
 [0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1],
 [0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1],
 [0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0],
 [0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0],
 [1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0],
 [1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0],
 [1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0],
 [1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0],
 [1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],
 [0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0],
 [0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
 [0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
 [0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
 [0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
 [0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1],
 [0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1],
 [0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1],
 [0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1], …

例如,我们有系列1,2,3,4,5.我们采用每3个元素=> 3,1,5,2,4(选择的元素不应该保留,我们可以采用系列不为空).圈子双向链表的朴素实现不是表现的好主意.你能给我一个建议,哪些数据结构和算法更适用？

foo.value_or(bar())我在代码中使用时遇到了麻烦，因为我不希望当可选变量有值bar()时调用该函数。foo我发现这个问题解释了value_or()不使用惰性求值。

现在我想知道为什么会这样，惰性求值一直是 C 和 C++ 中条件语句的标准方面。我发现这非常违反直觉，我认为我不是第一个也不会是最后一个被它绊倒的人。由于存在要求了解设计者想法的风险std::optional，是否有一个用例可以解释为什么惰性评估在这里不是一个好主意？