Làm thế nào để làm tròn kết quả của phép chia số nguyên?

Tôi đang suy nghĩ cụ thể về cách hiển thị các điều khiển phân trang, khi sử dụng ngôn ngữ như C # hoặc Java.

Nếu tôi có x mục mà tôi muốn hiển thị theo từng khối y trên mỗi trang thì sẽ cần bao nhiêu trang?

Tìm thấy một giải pháp thanh lịch:

int pageCount = (records + recordsPerPage - 1) / recordsPerPage;

Nguồn: Chuyển đổi số, Roland Backhouse, 2001

Chuyển đổi sang điểm nổi và trở lại có vẻ như là một sự lãng phí rất lớn thời gian ở cấp độ CPU.

Giải pháp của Ian Nelson:

int pageCount = (records + recordsPerPage - 1) / recordsPerPage;

Có thể được đơn giản hóa để:

int pageCount = (records - 1) / recordsPerPage + 1;

AFAICS, đây không phải là lỗi tràn mà Brandon DuRette đã chỉ ra và vì nó chỉ sử dụng một lần, nên bạn không cần lưu trữ recordsPerPage đặc biệt nếu nó xuất phát từ một hàm đắt tiền để lấy giá trị từ tệp cấu hình hoặc một cái gì đó

Tức là điều này có thể không hiệu quả, nếu config.fetch_value sử dụng tra cứu cơ sở dữ liệu hoặc một cái gì đó:

int pageCount = (records + config.fetch_value('records per page') - 1) / config.fetch_value('records per page');

Điều này tạo ra một biến bạn không thực sự cần, có thể có ý nghĩa bộ nhớ (nhỏ) và chỉ cần gõ quá nhiều:

int recordsPerPage = config.fetch_value('records per page')
int pageCount = (records + recordsPerPage - 1) / recordsPerPage;

Đây là tất cả một dòng và chỉ tìm nạp dữ liệu một lần:

int pageCount = (records - 1) / config.fetch_value('records per page') + 1;

Đối với C #, giải pháp là truyền các giá trị thành gấp đôi (vì Math.Cading mất gấp đôi):

int nPages = (int)Math.Ceiling((double)nItems / (double)nItemsPerPage);

Trong java, bạn nên làm tương tự với Math.ceil ().

Điều này sẽ cung cấp cho bạn những gì bạn muốn. Bạn chắc chắn sẽ muốn x mục chia cho y mục trên mỗi trang, vấn đề là khi số lượng không đồng đều xuất hiện, vì vậy nếu có một trang chúng tôi cũng muốn thêm một trang.

int x = number_of_items;
int y = items_per_page;

// with out library
int pages = x/y + (x % y > 0 ? 1 : 0)

// with library
int pages = (int)Math.Ceiling((double)x / (double)y);

Giải pháp toán học số nguyên mà Ian cung cấp là tốt, nhưng bị lỗi tràn số nguyên. Giả sử các biến là tất cả int, giải pháp có thể được viết lại để sử dụng longtoán học và tránh lỗi:

int pageCount = (-1L + records + recordsPerPage) / recordsPerPage;

Nếu recordslà một long, lỗi vẫn còn. Các giải pháp mô-đun không có lỗi.

Một biến thể của câu trả lời của Nick Berardi mà tránh một nhánh:

int q = records / recordsPerPage, r = records % recordsPerPage;
int pageCount = q - (-r >> (Integer.SIZE - 1));

Lưu ý: (-r >> (Integer.SIZE - 1))bao gồm bit dấu của r, được lặp lại 32 lần (nhờ phần mở rộng dấu của >>toán tử.) Điều này ước tính thành 0 nếu rbằng 0 hoặc âm, -1 nếu rlà dương. Vì vậy, trừ nó ra qcó tác dụng thêm 1 nếu records % recordsPerPage > 0.

Đối với các bản ghi == 0, giải pháp của rjmunro cho 1. Giải pháp đúng là 0. Điều đó nói rằng, nếu bạn biết rằng các bản ghi> 0 (và tôi chắc chắn rằng tất cả chúng ta đều giả sử recordsPerPage> 0), thì giải pháp rjmunro cho kết quả chính xác và không có bất kỳ vấn đề tràn.

int pageCount = 0;
if (records > 0)
{
    pageCount = (((records - 1) / recordsPerPage) + 1);
}
// no else required

Tất cả các giải pháp toán học số nguyên sẽ hiệu quả hơn bất kỳ giải pháp dấu phẩy động nào.

Cần một phương pháp mở rộng:

    public static int DivideUp(this int dividend, int divisor)
    {
        return (dividend + (divisor - 1)) / divisor;
    }

Không có kiểm tra nào ở đây (tràn, DivideByZerov.v.), vui lòng thêm nếu bạn muốn. Nhân tiện, đối với những người lo lắng về phí gọi phương thức, các hàm đơn giản như thế này có thể được trình biên dịch nội tuyến đưa vào, vì vậy tôi không nghĩ đó là nơi cần quan tâm. Chúc mừng.

PS bạn cũng có thể thấy hữu ích khi nhận thức được điều này (phần còn lại):

    int remainder; 
    int result = Math.DivRem(dividend, divisor, out remainder);

Một cách khác là sử dụng hàm mod () (hoặc '%'). Nếu có phần dư khác không thì tăng kết quả số nguyên của phép chia.

Tôi làm như sau, xử lý bất kỳ tràn:

var totalPages = totalResults.IsDivisble(recordsperpage) ? totalResults/(recordsperpage) : totalResults/(recordsperpage) + 1;

Và sử dụng tiện ích mở rộng này nếu có 0 kết quả:

public static bool IsDivisble(this int x, int n)
{
           return (x%n) == 0;
}

Ngoài ra, đối với số trang hiện tại (không được hỏi nhưng có thể hữu ích):

var currentPage = (int) Math.Ceiling(recordsperpage/(double) recordsperpage) + 1;

Thay thế để loại bỏ phân nhánh trong thử nghiệm cho không:

int pageCount = (records + recordsPerPage - 1) / recordsPerPage * (records != 0);

Không chắc chắn nếu điều này sẽ hoạt động trong C #, nên làm trong C / C ++.

Một phương pháp chung, mà kết quả mà bạn có thể lặp lại có thể được quan tâm:

public static Object[][] chunk(Object[] src, int chunkSize) {

    int overflow = src.length%chunkSize;
    int numChunks = (src.length/chunkSize) + (overflow>0?1:0);
    Object[][] dest = new Object[numChunks][];      
    for (int i=0; i<numChunks; i++) {
        dest[i] = new Object[ (i<numChunks-1 || overflow==0) ? chunkSize : overflow ];
        System.arraycopy(src, i*chunkSize, dest[i], 0, dest[i].length); 
    }
    return dest;
}

Tôi có một nhu cầu tương tự khi tôi cần chuyển đổi Phút thành giờ & phút. Những gì tôi đã sử dụng là:

int hrs = 0; int mins = 0;

float tm = totalmins;

if ( tm > 60 ) ( hrs = (int) (tm / 60);

mins = (int) (tm - (hrs * 60));

System.out.println("Total time in Hours & Minutes = " + hrs + ":" + mins);

Sau đây nên làm tròn tốt hơn các giải pháp trên, nhưng với chi phí hiệu năng (do tính toán dấu phẩy động 0,5 * rctDenominator):

uint64_t integerDivide( const uint64_t& rctNumerator, const uint64_t& rctDenominator )
{
  // Ensure .5 upwards is rounded up (otherwise integer division just truncates - ie gives no remainder)
  return (rctDenominator == 0) ? 0 : (rctNumerator + (int)(0.5*rctDenominator)) / rctDenominator;
}

Bạn sẽ muốn thực hiện phép chia dấu phẩy động, sau đó sử dụng hàm trần để làm tròn giá trị cho số nguyên tiếp theo.