如何将数字的后三位转换为0
示例 3444678 到 3444000
我可以做到
(int)(3444678/1000) * 1000= 3444000
但是除法和乘法可能代价高昂......
还有什么办法吗？？？？
【问题讨论】：
标签： optimization math
你可以试试
n - (n % 1000)
但是模运算符可能与除法一样昂贵。无论如何，这听起来很像微优化。这真的是你的瓶颈吗？
【讨论】：
换档技巧，然后：
n >>= 3;
n -= n % (5 * 5 * 5);
n <<= 3;
更快吗？值得怀疑。
但这里有一个有趣的事实：gcc 不为此使用除法/模数：
n -= n % 1000;
它乘以某个疯狂的数字 (274877907) 并执行一些其他可能更快的操作。
这个故事的寓意：您的代码对编译器的目的越明显，编译器就越有可能以您从未想过的方式对其进行优化。如果代码更容易被人类理解，那就是另一个好处了。
【讨论】：
顺便说一句（你已经在这里得到了很好的输入）。
位操作永远不能用于十进制数。问题是位的值根本不映射到十进制。使用 BCD 效果很好，但没有人使用它（也许 BigDecimal 会？我对此表示怀疑）。
无论如何，您可以使用的一个以 10 为基数的技巧是乘以 10 倍数，但除非您在 1970 年代的 CPU 上编写汇编代码，否则这是不值得的；但是因为它污染了我的记忆库，所以我会发布它以供您娱乐：
int mult10(int val) {
int tmp_2val = val << 1; // double val
int tmp_8val = val << 3; // 8x val
return( tmp_2val + tmp_8val ); // 2x + 8x = 10x
}
但是数学协处理器可以比这快得多，只是永远不要优化！您甚至将执行速度考虑在内这一事实是一个问题，您的“优化”通常会减慢系统速度而不是加快系统速度。
我相信您可以使用类似的方法除以 10，但我不会试图弄清楚 - 已经晚了 - 如果我没记错的话，它与检查移出的位有关根据值重新添加值。
【讨论】：
如果你正在处理八进制，你可以简单地：
x &= ~0777;
如果你正在使用十六进制，你可以简单地：
x &= ~0xfff;
但是对于十进制，您可能应该按照 Jesse Beder 建议的方式进行操作：
x -= (x % 1000);
大多数系统都有快速整数除法；如果您正在使用的系统没有，您可以使用double dabble 算法快速转换为 bcd。查看关于除以十的部分。
根据您尝试执行的其他操作，将数字转换为 Avitus 建议的可打印（字符串）格式时可能更容易截断。
【讨论】：
int takeAway(int num)
{
for (int i = 1; i =< 3; i++)
{
num = num/10;
}
return num;
}
int addZeroes(int num)
{
for (int i = 1; i =< 3; i++)
{
num = num*10;
}
return num;
}
然后你只需调用 takeAway 然后 addZeroes。再简单不过了！
我很想添加一个 int temp = num 然后使用它，但我认为这太多了，即使对于这段代码也是如此。
【讨论】：
如果您想四舍五入到任意精度并且您的舍入方法缺乏精度控制，这应该可以：
原因如下： ( 10 ** 7 ) * 3 个随机浮点数的样本产生了这个基准：
Dividing
Time taken was 7 wallclock secs ( 6.83 usr 0.00 sys + 0.00 cusr 0.00 csys = 6.83 CPU) seconds
Multiplying
Time taken was 7 wallclock secs ( 6.67 usr 0.00 sys + 0.00 cusr 0.00 csys = 6.67 CPU) seconds
Modding
Time taken was 8 wallclock secs ( 7.87 usr 0.00 sys + 0.00 cusr 0.00 csys = 7.87 CPU) seconds
Multiply + Dividing
Time taken was 10 wallclock secs (10.18 usr 0.01 sys + 0.00 cusr 0.00 csys = 10.19 CPU) seconds
请注意，10 ** 7 * 3 是 REDICULOUS 的浮点数。我不能使用 10**8 浮点数，因为为了公平测试，我必须对所有测试使用相同的浮点数序列，而且许多浮点数耗尽了我的 4G 内存
好的，有点偏题了：/
（仅使用 Int 的 Perl 实现，通常截断而不是四舍五入）
use strict;
use warnings;
use version;
our $VERSION = qv('0.1');
sub xround {
my ( $number, $precision ) = @_ ;
if ( $precision eq 0 )
{
return int( $number + .5 );
}
my $scale = 10 ** abs( $precision ) ;
$number = $number / $scale if $precision > 0;
$number = $number * $scale if $precision < 0;
$number = int( $number + .5 );
$number = $number * $scale if $precision > 0;
$number = $number / $scale if $precision < 0;
return $number;
}
my $fmt = "%s : %s ( %s )\n";
my $n = 55555.55555;
for my $i ( -4 .. 4 )
{
printf $fmt, $n, xround($n, $i), $i;
}
.
55555.55555 : 55555.5556 ( -4 )
55555.55555 : 55555.556 ( -3 )
55555.55555 : 55555.56 ( -2 )
55555.55555 : 55555.6 ( -1 )
55555.55555 : 55556 ( 0 )
55555.55555 : 55560 ( 1 )
55555.55555 : 55600 ( 2 )
55555.55555 : 56000 ( 3 )
55555.55555 : 60000 ( 4 )
这和上面一样工作，（除了没有四舍五入）使用整数的模数方法，但仍然适用于四舍五入到浮点精度（小数点右边的精度有点慢。
use strict;
use warnings;
use version;
our $VERSION = qv('0.1');
sub xround {
my ( $number, $precision ) = @_;
my $ino = int( $number );
if ( $precision eq 0 ) {
return $ino;
}
my $power = 10**$precision;
if ( $precision > 0 ) {
return int( $number - ( $number % $power ) );
}
return $ino + int( ( $number - $ino ) / $power ) * $power;
}
my $fmt = "%s : %s ( %s )\n";
my $n = 55555.55555;
for my $i ( -4 .. 4 )
{
printf $fmt, $n, xround($n, $i), $i;
}
.
55555.55555 : 55555.5555 ( -4 )
55555.55555 : 55555.555 ( -3 )
55555.55555 : 55555.55 ( -2 )
55555.55555 : 55555.5 ( -1 )
55555.55555 : 55555 ( 0 )
55555.55555 : 55550 ( 1 )
55555.55555 : 55500 ( 2 )
55555.55555 : 55000 ( 3 )
55555.55555 : 50000 ( 4 )
【讨论】：