เพดานอย่างรวดเร็วของการหารจำนวนเต็มใน C / C ++

รับค่าจำนวนเต็มxและyC และ C ++ กลับทั้งสองเป็นผลหารหารq = x/yด้วยจำนวนจุดลอยตัว ฉันสนใจวิธีการคืนเพดานแทน ยกตัวอย่างเช่นและceil(10/5)=2ceil(11/5)=3

วิธีการที่ชัดเจนเกี่ยวข้องกับสิ่งที่ชอบ:

q = x / y;
if (q * y < x) ++q;

สิ่งนี้ต้องการการเปรียบเทียบและการคูณที่พิเศษ และวิธีการอื่น ๆ ที่ผมเคยเห็น (ใช้ในความเป็นจริง) เกี่ยวข้องกับการหล่อเป็นหรือfloat doubleมีวิธีที่ตรงกว่าที่จะหลีกเลี่ยงการเพิ่มการคูณ (หรือการหารที่สอง) และสาขาและหลีกเลี่ยงการร่ายเป็นเลขทศนิยมหรือไม่?

สำหรับตัวเลขบวก

unsigned int x, y, q;

เพื่อปัดเศษขึ้น ...

q = (x + y - 1) / y;

หรือ (หลีกเลี่ยงการโอเวอร์โฟลว์ใน x + y)

q = 1 + ((x - 1) / y); // if x != 0

สำหรับตัวเลขบวก:

    q = x/y + (x % y != 0);

คำตอบของ Sparky เป็นวิธีมาตรฐานในการแก้ปัญหานี้ แต่ในขณะที่ฉันเขียนไว้ในความคิดเห็นของคุณคุณก็เสี่ยงต่อการล้น สิ่งนี้สามารถแก้ไขได้โดยใช้ชนิดที่กว้างขึ้น แต่ถ้าคุณต้องการหารlong longs?

คำตอบของ Nathan Ernst เป็นคำตอบเดียว แต่มันเกี่ยวข้องกับการเรียกฟังก์ชันการประกาศตัวแปรและเงื่อนไขซึ่งทำให้ไม่สั้นกว่ารหัส OPs และอาจช้ากว่าเพราะยากต่อการปรับให้เหมาะสม

ทางออกของฉันคือ:

q = (x % y) ? x / y + 1 : x / y;

มันจะเร็วกว่าโค้ด OPs เล็กน้อยเนื่องจากโมดูโลและการหารนั้นใช้คำสั่งเดียวกันบนโปรเซสเซอร์เนื่องจากคอมไพเลอร์สามารถเห็นได้ว่ามันเทียบเท่ากัน อย่างน้อย gcc 4.4.1 ทำการปรับให้เหมาะสมนี้ด้วยแฟล็ก -O2 บน x86

ในทางทฤษฎีแล้วผู้รวบรวมอาจอินไลน์การเรียกใช้ฟังก์ชันในโค้ดของ Nathan Ernst และปล่อยสิ่งเดียวกัน แต่ gcc ไม่ได้ทำอย่างนั้นเมื่อฉันทดสอบ อาจเป็นเพราะมันจะผูกรหัสที่คอมไพล์กับไลบรารี่มาตรฐานรุ่นเดียว

ในฐานะที่เป็นบันทึกสุดท้ายไม่มีสิ่งใดที่เกิดขึ้นกับเครื่องจักรที่ทันสมัยยกเว้นในกรณีที่คุณอยู่ในวงวนอย่างมากและข้อมูลทั้งหมดของคุณอยู่ในทะเบียน มิฉะนั้นโซลูชันเหล่านี้ทั้งหมดจะเร็วพอ ๆ กันยกเว้นอาจเป็นไปได้ของ Nathan Ernst ซึ่งอาจช้าลงอย่างมากหากฟังก์ชันต้องดึงข้อมูลจากหน่วยความจำหลัก

คุณสามารถใช้divฟังก์ชั่นใน cstdlib เพื่อให้ได้ค่าหาร & ส่วนที่เหลือในการโทรครั้งเดียวแล้วจัดการเพดานแยกต่างหากเช่นในด้านล่าง

#include <cstdlib>
#include <iostream>

int div_ceil(int numerator, int denominator)
{
        std::div_t res = std::div(numerator, denominator);
        return res.rem ? (res.quot + 1) : res.quot;
}

int main(int, const char**)
{
        std::cout << "10 / 5 = " << div_ceil(10, 5) << std::endl;
        std::cout << "11 / 5 = " << div_ceil(11, 5) << std::endl;

        return 0;
}

แล้วเรื่องนี้ล่ะ (ต้องการ y ที่ไม่เป็นลบดังนั้นอย่าใช้สิ่งนี้ในกรณีที่หายากโดยที่ y เป็นตัวแปรที่ไม่มีการรับประกันที่ไม่ใช่ลบ)

q = (x > 0)? 1 + (x - 1)/y: (x / y);

ฉันลดเหลือy/yหนึ่งลบคำx + y - 1และมีโอกาสล้นใด ๆ

ฉันหลีกเลี่ยงการx - 1พันเมื่อxเป็นประเภทที่ไม่ได้ลงชื่อและมีค่าเป็นศูนย์

สำหรับเซ็นชื่อxเชิงลบและศูนย์ยังคงรวมกันเป็นกรณีเดียว

อาจไม่ใช่ประโยชน์อย่างมากสำหรับซีพียูที่ใช้งานทั่วไปที่ทันสมัย ​​แต่มันจะเร็วกว่าในระบบฝังตัวมากกว่าคำตอบที่ถูกต้องอื่น ๆ

มีวิธีแก้ปัญหาสำหรับทั้งบวกและลบxแต่สำหรับบวกyมีเพียง 1 แผนกและไม่มีสาขา:

int ceil(int x, int y) {
    return x / y + (x % y > 0);
}

หมายเหตุถ้าxเป็นบวกแล้วการหารนั้นมีค่าเป็นศูนย์และเราควรเพิ่ม 1 ถ้าการเตือนไม่ใช่ศูนย์

ถ้าxเป็นลบแล้วการหารนั้นมีค่าเป็นศูนย์นั่นคือสิ่งที่เราต้องการและเราจะไม่เพิ่มอะไรเลยเพราะx % yไม่ใช่เชิงบวก

ใช้งานได้กับจำนวนบวกหรือลบ:

q = x / y + ((x % y != 0) ? !((x > 0) ^ (y > 0)) : 0);

หากมีส่วนที่เหลือจะตรวจสอบเพื่อดูว่าxและyมีเครื่องหมายเดียวกันและเพิ่ม1ตาม

ฉันจะได้แสดงความคิดเห็นค่อนข้าง แต่ฉันไม่ได้มีตัวแทนสูงพอ

เท่าที่ฉันทราบสำหรับข้อโต้แย้งเชิงบวกและตัวหารซึ่งเป็นพลังของ 2 นี้เป็นวิธีที่เร็วที่สุด (ทดสอบใน CUDA):

//example y=8
q = (x >> 3) + !!(x & 7);

สำหรับข้อโต้แย้งเชิงบวกทั่วไปเท่านั้นฉันมักจะทำเช่นนั้น:

q = x/y + !!(x % y);

แบบฟอร์มทั่วไปที่ง่ายขึ้น

int div_up(int n, int d) {
    return n / d + (((n < 0) ^ (d > 0)) && (n % d));
} //i.e. +1 iff (not exact int && positive result)

สำหรับคำตอบทั่วไปเพิ่มเติมฟังก์ชัน C ++ สำหรับการหารจำนวนเต็มพร้อมกลยุทธ์การปัดเศษที่กำหนดไว้อย่างดี

คอมไพล์ด้วย O3 คอมไพเลอร์ทำงานได้ดีที่สุด

q = x / y;
if (x % y)  ++q;