标签: binary-operators

给定's和's 的n行和m列矩阵,需要找出可以选择的行对的数量,以便它们是.10OR11111....m times

例:

1 0 1 0 1
0 1 0 0 1
1 1 1 1 0

回答:

2 ---> OR of row number [1,3] and [2,3]

鉴于n并且m可能是一个订单<= 3000,这个问题的解决效率如何？

PS:我已经尝试过一种天真的O(n*n*m)方法.我在考虑一个更好的解决方案.

我正在创建一个包含类似于的表达式的解析树

3 - 4 * 8

要么

8 * -5

要么

-(10 * 1)

我需要一种方法来区分一元和二元减.我的语法现在的方式是二进制减去第一个,但我想改变它并添加一个保存最后一个变量的标志变量.

例如:如果是的话 5 - 6

该标志持有5,如果它看到减号并且标志是数字,则跳过一元并转到二进制.

但是我不确定如何在C++中实现它

任何帮助将不胜感激.

谢谢

我正在为我的控制结构类编写一个程序,我正在尝试编译它.唯一的错误,至少是编译器拾取的唯一错误是将类型为'double'和'int'的无效操作数指向二进制'operator%'.大多数程序都不包括在内,因为它太长并且与这个问题无关,至少我不相信.

double maxTotal, minTotal;

cin >> maxTotal >> minTotal;

int addCalc;

static_cast<int>(maxTotal);

if(maxTotal % 2 == 1)
     addCalc = minTotal;
else
     addCalc = 0;

我目前正在阅读O'reilly Java 8 Lambdas是一本非常好的书.我遇到过这样的例子.

我有一个

private final BiFunction<StringBuilder,String,StringBuilder>accumulator=
(builder,name)->{if(builder.length()>0)builder.append(",");builder.append("Mister:").append(name);return builder;};

final Stream<String>stringStream = Stream.of("John Lennon","Paul Mccartney"
,"George Harrison","Ringo Starr");
final StringBuilder reduce = stringStream
    .filter(a->a!=null)
    .reduce(new StringBuilder(),accumulator,(left,right)->left.append(right));
 System.out.println(reduce);
 System.out.println(reduce.length());

这产生了正确的输出.

Mister:John Lennon,Mister:Paul Mccartney,Mister:George Harrison,Mister:Ringo Starr

我的问题被认为是reduce最后一个参数的方法BinaryOperator

我的问题是这个参数用于哪个？如果我改变

.reduce(new StringBuilder(),accumulator,(left,right)->new StringBuilder());

如果我通过,NULL那么输出是相同的,然后返回NPE.

这个参数用于什么？

UPDATE

为什么如果我运行它parallelStream我收到不同的结果？

第一次运行.

returned StringBuilder length = 420

第二轮

returned StringBuilder length = 546

第三次运行

returned StringBuilder length = 348

等等？为什么这个...不应该在每次迭代时返回所有值？

任何帮助都非常感激.

谢谢.

我正在尝试重构我使用指针而不使用指针的寻路算法的一部分。不幸的是，我对参考文献不是那么了解。我收到错误：Invalid operands to binary expression ('std::__1::reference_wrapper<Tile>' and 'const std::__1::reference_wrapper<Tile>')

我也不知道这意味着什么。我的代码在下面，我可以推测它来自以下行：openList.erase(std::find(openList.begin(), openList.end(), current));但我不确定如何解决这个问题。

bool TileMap::tilesBetween(Tile& p_start, Tile& p_end)
{
    std::vector<std::reference_wrapper<Tile>> openList;
    std::vector<std::reference_wrapper<Tile>> closedList;

    openList.push_back(p_start);

    do
    {
        std::sort(openList.begin(), openList.end(), sortF());
        Tile& current = openList[0];
        closedList.push_back(current);
        openList.erase(std::find(openList.begin(), openList.end(), current));
        if(std::find(closedList.begin(), closedList.end(), p_end) != closedList.end())
        {
            return true;
        }

        std::vector<std::reference_wrapper<Tile>> adjacentTiles;
        if (current.m_coordinates.x > 0)
        {
            adjacentTiles.push_back(m_tiles[current.m_coordinates.y * m_width + (current.m_coordinates.x - 1)]);
        }
        if (current.m_coordinates.x < m_width)
        {
            adjacentTiles.push_back(m_tiles[current.m_coordinates.y * m_width + (current.m_coordinates.x + 1)]);
        }
        if (current.m_coordinates.y > 0) …

Rust Reference目前对as运营商说:

7.2.12.5类型转换表达式

类型转换表达式用二元运算符表示as.

执行as表达式会将左侧的值转换为右侧的类型.

as表达式的一个例子:

fn average(values: &[f64]) -> f64 {
  let sum: f64 = sum(values);
  let size: f64 = len(values) as f64;
  sum / size
}

Run Code Online (Sandbox Code Playgroud)

(另外,因为它是相关的:

7.2.12.8运算符优先级

Rust二元运算符的优先级按如下顺序排列,从强到弱:

as
* / %
+ -
<< >>

Run Code Online (Sandbox Code Playgroud)

)

天真地使用它作为运算符似乎不起作用:

fn main() {
    let x = 100 as u16 << 8;
}

实际上没有编译:

% rustc testing.rs
testing.rs:2:24: 2:25 error: expected type, found `8`
testing.rs:2    let x = 100 as u16 …

当我在 上使用位移位时byte，我注意到使用无符号右移 ( >>>)时得到了奇怪的结果。使用int，右移（signed:>>和 unsigned: >>>）都按预期运行：

    int min1 = Integer.MIN_VALUE>>31; //min1 = -1
    int min2 = Integer.MIN_VALUE>>>31; //min2 = 1

但是当我对 做同样的byte事情时，无符号右移会发生奇怪的事情：

    byte b1 = Byte.MIN_VALUE; //b1 = -128
    b1 >>= 7; //b1 = -1

    byte b2 = Byte.MIN_VALUE; //b2 = -128
    b2 >>>= 7; //b2 = -1; NOT 1!
    b2 >>>= 8; //b2 = -1; NOT 0!

我认为可能是编译器在内部将 转换byte为int，但似乎不足以解释这种行为。

为什么在 Java 中对字节进行位移位的行为是这样的？

在 Haskell 中，我们可以写

print $ abs $ 3 - 5

使用$。

在 F# 中，我们可以这样写

printfn "%d" << abs <| 3 - 5

然而，在 F# 中的许多情况下，具有相同的功能也很有用，$因为上面只是带有二元运算符的表达式。

Haskell 的技巧$是它的二元运算符中优先级最低。

于是我又调查了一下

https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/#operator-precedence

不幸的是，我观察到，没有优先级较低的运算符可以安全地重载，因为它们似乎都是必不可少的。

您对此有什么想法吗？

你认为$F# 中的 Haskell 可能吗？

可能重复:
无符号整数中的C反转位

如何仅使用二元运算符反转二进制数？

例如:

11100000 -> 00000111
00110100 -> 00101100
00111111 -> 11111100

c中是否有任何一元和二元的运算符？在一次采访中提出了这个问题.