标签: integer-overflow

这是我在 Java 上模拟 Collat​​z 猜想的程序：

import java.util.*;
public class Collatz {
public static void main(String args[]){
    Scanner raj= new Scanner(System.in);
    int n;
    int k=0;
    System.out.print("n? ");
    n = raj.nextInt();
    while(n > 1){
        if(n%2 ==1){
            n=3*n+1;
            System.out.println(n);
            k++;
        }
        if(n%2==0){
            n=n/2;
            System.out.println(n);
            k++;
        }

    }
    System.out.print("It took " + k + " iterations!");
}

}

当我输入 n=6 时，我得到

3 10 5 16 8 4 2 1 迭代了 8 次！

但是当我输入 n= 63728127 时，我得到

191184382 95592191 286776574 143388287 430164862 215082431 645247294 322623647 …

有没有一个公式可以计算 Java int 的溢出情况？

示例：如果我加 1，则Integer.MAX_VALUE;答案不是 2147483648，而是 -2147483648。

问题：如果我想计算 Java 将打印大于 2^32 的值，是否有一个简单的数学表达式（理论上的，而不是代码中的）？

如果我有 2 个int或long long变量，调用它们aand b，并且我想计算 sum (a + b) mod p，其中 p 是一个大素数整数，我如何利用 C++ 中的模运算符来获得所需的结果？

我试过(a + b) % p，但这有时a + b会导致溢出，因为会在应用 mod 之前溢出。

我尝试过的其他类似方法似乎可以避免溢出，但会给出不正确的结果。

在这种情况下，如何使用模运算符正确计算所需的总和，同时避免溢出？

我希望这将是一个我想念的傻事,但我一直在敲击键盘试图弄清楚我哪里出错了.

我正在尝试从新线程中的DownloadManager更新ProgressBar.这是正常工作,直到中途,ProgressBar重新开始重新开始.从输入一些调试代码,我已将问题隔离到这一行:

final int dl_progress = (bytes_downloaded*100)/bytes_total;

dl_progress正在通过文件下载中途转为负面!下面的相关代码块和日志输出:

    @Override
    public void run() {

        boolean downloading = true;

        while (downloading) {

            DownloadManager.Query q = new DownloadManager.Query();
            q.setFilterById(downloadId);

            Cursor cursor = manager.query(q);
            cursor.moveToFirst();
            int bytes_downloaded = cursor.getInt(cursor
                    .getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
            int bytes_total = cursor.getInt(cursor
                    .getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));

            if (cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS)) == DownloadManager.STATUS_SUCCESSFUL) {
                downloading = false;
                getActivity().runOnUiThread(new Runnable() {
                    public void run() {
                        mProgressBar.setVisibility(View.INVISIBLE);
                    }
                });
            }

            final int dl_progress = (bytes_downloaded*100)/bytes_total;

            Log.d("Download", bytes_downloaded + " of " + bytes_total + " (" + dl_progress + …

我有一个代码,由于我正在处理大数字,因此输出错误.我想要一个解决方案,我怎么能改善它以适应大数字. 我应该使用哪种数据类型？

码:

    static int get(int n,int i,int digit)
    {
      int p;
      p=(int)Math.pow(10,i-1);
      n=n/p;
      return n%10;
    }
    static boolean check_pal(int n)
    {
      int digit;
      digit=(int) (Math.log10(n)+1);
      int a=0,b=0,i,j,p;
      int sum=0;
      for(i=1,j=digit-1 ; i<=digit ; i++,j-- )
      {
        a=(int) get(n,i,digit);
        sum+=a*Math.pow(10,j);
      }
      if(sum==n)
        return true;
      else
        return false;
    }
    static int reverse(int n)
    {
        int digit;
        digit=(int) (Math.log10(n)+1);
        int a=0,b=0,i,j,p;
        int sum=0;
        for(i=1,j=digit-1 ; i<=digit ; i++,j-- )
        {
            a=(int) get(n,i,digit);
            sum+=a*Math.pow(10,j);
        }
        return n+sum;
    }
    public static void main(String[] args) …

我特林实现C/C++中的atoi功能的Java,以下是代码片段

    for (int j = 0; j < s.length(); j++) {

        int digit = Character.digit(s.charAt(j), 10);
        if (sum < limit/10) {
            if (neg) return Integer.MIN_VALUE;
            return Integer.MAX_VALUE;
        }

        sum *= 10;
        if (sum < limit + digit) {
            if (neg) return Integer.MIN_VALUE;
            return Integer.MAX_VALUE;
        }
        sum -= digit;
    }

对于行"if (sum < limit + digit) {",这是正确的,但是,如果我使用"sum - digit < limit",它将得到错误的结果,例如输入"-2147483649",错误的结果2147483647,应该是-2147483648.

我想出来了,因为总和 - 数字可能会溢出,所以这又出现了另一个问题:

    int sum = Integer.MAX_VALUE;
    System.out.println(sum < Integer.MAX_VALUE + 1); …

我正在尝试编写一个在不受约束的输入下表现良好的累加器.这似乎不是微不足道的,需要一些非常严格的计划.这真的很难吗？

int naive_accumulator(unsigned int max,
                      unsigned int *accumulator,
                      unsigned int amount) {
    if(*accumulator + amount >= max) {
        return 1; // could overflow
    }

    *accumulator += max; // could overflow

    return 0;
}

int safe_accumulator(unsigned int max,
                     unsigned int *accumulator,
                     unsigned int amount) {
    // if amount >= max, then certainly *accumulator + amount >= max
    if(amount >= max) {
        return 1;
    }

    // based on the comparison above, max - amount is defined
    // but *accumulator + amount might …

我的情况我不明白.当我做

 System.out.println(1<<30);

我得到了非常大的正数1073741824.但是当我这么做的时候

 System.out.println(1<<31);

我的号码非常低-2147483648.因为我读长类型是64位长.最大数量为2 ^ 63 -1.所以在这里,我不明白为什么我的转变为负面(((做)

System.out.println((long)(1<<31));

也给出了相同的结果(((

我有一个简单的电源功能,我想用两个大数字做这样的事情:

(def y 19859145917581983573N)
(def p 27829350753993985481N)
(defn power
  [x n]
  (reduce *' (repeat n x))
  )
(power y p)

我收到此错误:

IllegalArgumentException Value out of range for long: 27829350753993985481  clojure.lang.RT.longCast (RT.java:1210)

有没有办法解决这个问题？

有人可以向我解释这个C++行为吗？

for (int i=0;i<3;++i){
    int x;
    std::cin >> x;
    std::cout << x << std::endl;
}

如果我只输入一个大于INT_MAX的数字(如124124124124124),则输出:

2147483647
2147483647
2147483647 

我最好的猜测是它识别我的输入是一个数字,但它切片因为x只能适应2147483647.我不明白为什么在输入那个只有ONCE的大数字后,输入"溢出"到其他输入,然后打印2147483647三次,然后结束程序.