标签: integer-arithmetic

看看下面这段代码:

#include <stdio.h>

int main(void)  
{  
int a;

a = 2147483647;
printf("a + 1 = %d \t sizeof (a + 1) = %lu\n", a + 1, sizeof (a + 1));
printf("a + 1L = %ld \t sizeof (a + 1L) = %lu\n", a + 1L, sizeof (a + 1L));

a = -1;
printf("a + 1 = %d \t sizeof (a + 1) = %lu\n", a + 1, sizeof (a + 1));
printf("a + 1L = %ld \t sizeof (a + …

我对这段C代码有问题:

int y = 0, h = 640, ih = 640;
h = y + h - max(0, (y + h) - ih);

它应该将h设置为640,但它被设置为0!

你可以在这里看到它运行:http://ideone.com/zBZSsr

有关这种奇怪行为的任何想法？难道我做错了什么？

public class test {
  public static void main(String[] args) {
   int total = 2;
   int rn = 1;
   double rnp = (rn / total) * 100;
   System.out.println(rnp);
 }
}

为什么它打印0.0而不是50.0？

https://www.google.com/search?q=100*(1%2F2)&aq=f&oq=100*(1%2F2)

对于下面的代码我得到溢出但遗憾的是我似乎无法理解为什么.

std::int8_t smallValue         = -1;
unsigned int value             = 500;
std::uint8_t anotherSmallValue = 1;

auto test = smallValue * value * anotherSmallValue;

之后test是一个非常大的价值.

有人可以解释,这里发生了什么？

我试图理解算术溢出.假设我有以下,

unsigned long long x;
unsigned int y, z;

x = y*z;

y*z可能导致整数溢出.将其中一个操作数强制转换为unsigned long long可以缓解此问题.64位操作数与32位操作数相乘的预期结果是什么？

给定一个非负整数c,我需要一个高效的算法来找到最大的整数x使得

x*(x-1)/2 <= c

同样,我需要一个高效且可靠的精确算法来计算:

x = floor((1 + sqrt(1 + 8*c))/2)        (1)

为了定义,我标记了这个问题C++,所以答案应该是用该语言编写的函数.您可以假设这c是一个无符号的32位int.

此外,如果您可以证明(1)(或涉及浮点运算的等效表达式)总是给出正确的结果,那也是一个有效的答案,因为现代处理器上的浮点数可能比整数算法更快.

根据二进制算术规则,我有8位int zero = 0b00000000;和8位int one = 0b00000001;,

0 - 1 = 1(从下一个有效位借1).

所以,如果我有:

int s = zero - one; 
s = -1; 
-1 = 0b1111111;

所有这些1都来自哪里？有没有借到,因为所有位都0在zero变化.

我对fortran有一个有趣的问题.也就是说,当它试图将774840977乘以3并添加一个时,似乎会产生一致的算术错误,它打印出-1970444364,这显然不是正确的答案.现在,我认为它在其他几个地方犯了同样的错误,但是当它发生时很难找到它.下面的do循环通常会运行1-10,000,000,但此数字弹出的值是n = 786431,所以为了方便起见,我缩小了该值的边界.我认为这是一个整数限制的问题或类似于fortran的问题,但我想知道是否有任何方法可以在fortran中解决这个问题,或者我是否需要在其他方面尝试这个问题.对于我在这里所做的事情的背景,我正在通过collat​​z链,你可以看看那些好奇的.[算术步骤快照] [

      program Collatzthings
  implicit integer*4 (i-o)
  implicit doubleprecision*8 (a-h)
  integer*4 n0

  open(1,file='datac',status='unknown')
  e=0
  do 100 n0=786431,786431
     n=n0
     i=0
     j=0
    do while (n.GT.1)
      if (mod(n,2).EQ.0) then
        n=.5*n
        i=i+1
        j=(j+1)
      elseif (mod(n,2).EQ.1) then
        n=((3*n)+1)
        i=i+1
      endif
      write(6,*)n
    end do
    b=i
    c=j
    a=c/b
pause
    write(1,*)n0,i,a
100 continue
close(1)
stop
1000 format(7(g12.4,1x))
end

我得到数字3和变量'n',可以高达1 000 000 000(十亿).我必须打印答案3^n modulo 100003.我尝试了以下方法:

1. 我尝试使用该函数std::pow(3,n),但它不适用于大型指数(在此过程中无法应用模数).
2. 我尝试实现我自己的函数,将数字3提高到幂n,这样我就可以在需要时应用模数,但是当测试数量非常大时,这种方法被证明太慢了.

3. 最后,我尝试对数字'n'进行素数分解,然后使用'n'因子(以及它们出现的次数)来构建答案,这似乎是我能提出的最佳方法(如果是正确).问题是我会为已经素数很大的数字做些什么？

   所以这些是我的想法,如果有人认为有更好的方法(或者我的方法之一是最优的),我将不胜感激任何指导.

问题是当我执行“ for（int i = 0; i <vector.size（）-1; i ++）”时，它给我一个“向量下标超出范围”的错误。但是，如果我将vector.size（）-1放入变量中，它将起作用。这是小故障还是我只是想念一些东西？

这有效：

    int sizePos = positionsX.size() - 1;

    for (int i = 0; i < sizePos; i++) {
        if (snake.getX() == positionsX[i] && snake.getY() == positionsY[i]) {
            gameOver = true;
            std::cout << as << std::endl;
            as++;
        }

        if (apple.getX() == positionsX[i] && apple.getY() == positionsY[i]) {
            apple.eat();
        }
    }

并且这不会：

    for (int i = 0; i < positionsX.size() - 1; i++) {
        if (snake.getX() == positionsX[i] && snake.getY() == positionsY[i]) {
            gameOver …