Saya sedang membuat program untuk mencetak Angka Fibonacci ke-n.

Metode FIBBO(int n) menggunakan kombinasi tipe long dan BigInteger untuk menyimpan hasil operasi Fibonacci. Metode ini seharusnya beralih menggunakan BigInteger ketika dianggap prev+next>Long.MAX_VALUE menggunakan big_flag. Namun program ini hanya bekerja jika saya menggunakan Integer.MAX_VALUE di loop ke-2.

Ketika saya menggunakan Long.MAX_VALUE, loop ke-2 big_flag tidak pernah dipicu sekarang seberapa besar nilai n dan saya hanya mendapatkan nilai sampah. Saya tidak mengerti mengapa logika overflow saya tidak pernah diaktifkan ketika saya menggunakan Long.MAX_VALUE.

import java.util.*;
import java.math.*;

public class fibbo_iteration{
    public static void main(String argss[])
    {
        BigInteger result;                      
        Scanner input=new Scanner(System.in);
        int n=0;                                
        System.out.println("Enter number of terms for fibbonacci sequence");
        n=input.nextInt();
        if(n<0){
            System.out.println("Fibbonaci sequence cannot be generated for the entered negative value");
            System.exit(1);
        }
        
        result=fibbo_iteration.FIBBO(n);        //call
        System.out.println(result.toString());  
    }
    static BigInteger FIBBO(int n)
    {
        // variables
        long sum=0L,prev=0L,next=1L;
        BigInteger big_prev=new BigInteger("0"),big_next=new BigInteger("0"),big_sum=new BigInteger("0");
        boolean big_flag=false;
    
            for(int i=0;i<n;i++){
                if(big_flag){
                    // System.out.println(big_sum.toString()); to use when printing a series upto n 
                    big_prev=big_next;
                    big_next=big_sum;
                    big_sum=big_prev.add(big_next);
                }
                else if(prev+next>Long.MAX_VALUE){   // ***The program works abolutely correct if i replace LONG.MAX_VALUE with Integer.MAX_Value***
                    big_prev=new BigInteger(String.valueOf(prev));
                    big_next=new BigInteger(String.valueOf(next));
                    big_sum=big_prev.add(big_next);
                    big_flag=true;  // this is supposed to signal the switch to BigInteger
                    System.out.println("Value exceeds Long");
                }   
                else{
                    if(i==1){   // this if block accomodates the eccentricity of starting the fibbonaci sequence  
                        sum=1L;
                        continue;
                    }   
                sum=prev+next;
                prev=next;
                next=sum;
                System.out.println(sum);
                }
            }
        return big_flag==true?big_sum:new BigInteger(String.valueOf(sum));
    }
}   
3
Gestalt 25 Mei 2021, 16:37

2 jawaban

Jawaban Terbaik

Nilai maksimum Long benar-benar maksimum dari jenisnya. Perhitungan apa pun di atas ini memberi Anda ... hasil yang baik yang tampaknya tidak Anda harapkan. Cek jenis prev+next>Long.MAX_VALUE adalah omong kosong. Itu tidak akan pernah benar.

Sedikit perubahan yang seharusnya membuat program Anda berjalan adalah: prev > Long.MAX_VALUE - next

Jika Anda ingin memahami lebih detail, Anda dapat menggunakan perbandingan seperti yang saya tulis dan debug, menempatkan breakpoint di dalam blok if. Coba lihat nilai prev+next. Lihat bagaimana hasilnya negatif. Ini karena Anda telah mencapai nilai di luar yang dapat disimpan long.

6
Boris Strandjev 25 Mei 2021, 13:41

Alih-alih menggunakan tanda, gunakan Math.addExact(long,long). Mengelilingi menggunakan try-catch dan beralih ke BigInteger ketika Pengecualian dilemparkan.

    try
    {
        sum=Math.addExact(prev, next);
        prev=next;
        next=sum;
        System.out.println(sum);
    }
    catch(ArithmeticException overflow)//Out of range
    {
        big_prev=new BigInteger(String.valueOf(prev));
        big_next=new BigInteger(String.valueOf(next));
        big_sum=big_prev.add(big_next);
        big_flag=true;  // this is supposed to signal the switch to BigInteger
        System.out.println("Value exceeds Long");
    }

Lihat juga Integer Overflow.

0
PalLaden 25 Mei 2021, 14:22