计算不带分支的整数绝对值（abs）-yiteyi-C++库

如果一个数字是正的，我们不需要做任何事情。我们只想改变负数。因为负数存储在 2的补语形式，为了得到一个负数的绝对值，我们必须切换数字的位，并在结果中加1。例如，8位系统中的-2按如下方式存储，其中最左边的位是符号位。要获得负数的绝对值，我们必须切换所有位，并将1添加到切换的数字，即0 0 0 0 0 1+1将给出1 1 1 0的绝对值。还要记住，只有当数字为负数（设置了符号位）时，我们才需要执行这些操作。 方法1 1）将掩码设置为整数的右移31（假设使用32位存储整数）。

null

 mask = n>>31

2）对于负数，上述步骤将掩码设置为1，正数设置为0。将掩码添加到给定的数字。

 mask + n

3） mask+n和mask的异或给出绝对值。

 (mask + n)^mask

实施：

C++

                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
                         #define CHARBIT 8                       
           
                         /* This function will return absolute value of n*/                       
                         unsigned                                     int                                     getAbs(                                     int                                     n)                       
                         {                       
                                                 int                                     const                                     mask = n >> (                                     sizeof                                     (                                     int                                     ) * CHARBIT - 1);                       
                                                 return                                     ((n + mask) ^ mask);                       
                         }                       
           
                         /* Driver program to test above function */                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = -6;                       
                                                 cout <<                                     "Absolute value of "                                     << n <<                                     " is "                                     << getAbs(n);                       
                                                 return                                     0;                       
                         }                       
           
                         // This code is contributed by rathbhupendra                       

C

                         #include <stdio.h>                       
                         #define CHAR_BIT 8                       
           
                         /* This function will return absolute value of n*/                       
                         unsigned                                     int                                     getAbs(                                     int                                     n)                       
                         {                       
                                                 int                                     const                                     mask = n >> (                                     sizeof                                     (                                     int                                     ) * CHAR_BIT - 1);                       
                                                 return                                     ((n + mask) ^ mask);                       
                         }                       
           
                         /* Driver program to test above function */                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = -6;                       
                                                 printf                                     (                                     "Absolute value of %d is %u"                                     , n, getAbs(n));                       
           
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java implementation of above approach                       
                         class                                     GFG {                       
           
                                                 static                                     final                                     int                                     CHAR_BIT =                                     8                                     ;                       
                                                 static                                     final                                     int                                     SIZE_INT =                                     8                                     ;                       
           
                                                 /* This function will return absolute value of n*/                       
                                                 static                                     int                                     getAbs(                                     int                                     n)                       
                                                 {                       
                                                 int                                     mask = n >> (SIZE_INT * CHAR_BIT -                                     1                                     );                       
                                                 return                                     ((n + mask) ^ mask);                       
                                                 }                       
           
                                                 /* Driver code */                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     n = -                                     6                                     ;                       
                                                 System.out.print(                                     "Absolute value of "                                     + n +                                     " is "                                     + getAbs(n));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Rajput-Ji                       

蟒蛇3

                         # Python3 implementation of above approach                       
                         CHARBIT                                     =                                     8                                     ;                       
                         SIZE_INT                                     =                                     8                                     ;                       
           
                         # This function will return                       
                         # absolute value of n                       
                         def                                     getAbs(n):                       
                                                 mask                                     =                                     n >> (SIZE_INT                                     *                                     CHARBIT                                     -                                     1                                     );                       
                                                 return                                     ((n                                     +                                     mask) ^ mask);                       
           
                         # Driver Code                       
                         n                                     =                                     -                                     6                                     ;                       
                         print                                     (                                     "Absolute value of"                                     ,n,                                     "is"                                     ,getAbs(n));                       
           
                         # This code is contributed by mits                       

C#

                         // C# implementation of above approach                       
                         using                                     System;                       
           
                         class                                     GFG {                       
           
                                                 static                                     int                                     CHAR_BIT = 8;                       
                                                 static                                     int                                     SIZE_INT = 8;                       
           
                                                 /* This function will return absolute value of n*/                       
                                                 static                                     int                                     getAbs(                                     int                                     n)                       
                                                 {                       
                                                 int                                     mask = n >> (SIZE_INT * CHAR_BIT - 1);                       
                                                 return                                     ((n + mask) ^ mask);                       
                                                 }                       
           
                                                 /* Driver code */                       
                                                 static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     n = -6;                       
                                                 Console.Write(                                     "Absolute value of "                                     + n +                                     " is "                                     + getAbs(n));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by mits                       

PHP

                         <?php                       
                         // PHP implementation of above approach                       
                         $CHARBIT                                     = 8;                       
                         $SIZE_INT                                     = 8;                       
           
                         // This function will return                       
                         // absolute value of n                       
                         function                                     getAbs(                                     $n                                     )                       
                         {                       
                                                 global                                     $SIZE_INT                                     ,                                     $CHARBIT                                     ;                       
                                                 $mask                                     =                                     $n                                     >> (                                     $SIZE_INT                                     *                                     $CHARBIT                                     - 1);                       
                                                 return                                     ((                                     $n                                     +                                     $mask                                     ) ^                                     $mask                                     );                       
                         }                       
           
                         // Driver Code                       
                         $n                                     = -6;                       
                         echo                                     "Absolute value of "                                     .                                     $n                                     .                       
                                                 " is "                                     . getAbs(                                     $n                                     );                       
           
                         // This code is contributed by mits                       
                         ?>                       

Javascript

                         <script>                       
                         // javascript implementation of above approach                       
                         var                                     CHAR_BIT = 8;                       
                         var                                     SIZE_INT = 8;                       
           
                                                 /* This function will return absolute value of n */                       
                                                 function                                     getAbs(n)                       
                                                 {                       
                                                 var                                     mask = n >> (SIZE_INT * CHAR_BIT - 1);                       
                                                 return                                     ((n + mask) ^ mask);                       
                                                 }                       
           
                                                 /* Driver code */                       
                                                 var                                     n = -6;                       
                                                 document.write(                                     "Absolute value of "                                     + n +                                     " is "                                     + getAbs(n));                       
           
                         // This code is contributed by shikhasingrajput                       
                         </script>                       

输出：

Absolute value of -6 is 6

方法2： 1）将掩码设置为整数的右移31（假设使用32位存储整数）。

 mask = n>>31

2）用数字对面具进行异或运算

 mask ^ n

3）从第2步的结果中减去掩码并返回结果。

 (mask^n) - mask

实施：

C

                         /* This function will return absolute value of n*/                       
                         unsigned                                     int                                     getAbs(                                     int                                     n)                       
                         {                       
                                                 int                                     const                                     mask = n >> (                                     sizeof                                     (                                     int                                     ) * CHAR_BIT - 1);                       
                                                 return                                     ((n ^ mask) - mask);                       
                         }                       

JAVA

                         // Java implementation of above approach                       
                         class                                     GFG {                       
           
                                                 /* This function will return absolute value of n*/                       
                                                 static                                     int                                     getAbs(                                     int                                     n)                       
                                                 {                       
                                                 int                                     mask = n >> (SIZE_INT * CHAR_BIT -                                     1                                     );                       
                                                 return                                     ((n + mask) ^ mask);                       
                                                 }                       
           
                         }                       
           
                         // This code is contributed by code_hunt.                       

C#

                         // C# implementation of above approach                       
                         using                                     System;                       
           
                         public                                     class                                     GFG {                       
           
                                                 static                                     int                                     CHAR_BIT = 8;                       
                                                 static                                     int                                     SIZE_INT = 8;                       
                                   
                                                 /* This function will return absolute value of n*/                       
                                                 static                                     int                                     getAbs(                                     int                                     n)                       
                                                 {                       
                                                 int                                     mask = n >> (SIZE_INT * CHAR_BIT - 1);                       
                                                 return                                     ((n + mask) ^ mask);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Rajput-Ji                       

在分支代价高昂的机器上，上面的表达式可能比明显的方法r=（v<0）更快-（未签名）v:v，即使操作数相同。请看这有关上述两种方法的更多详细信息。如果您发现上述任何解释/算法不正确，或发现解决同一问题的更好方法，请写下评论。 参考资料： http://graphics.stanford.edu/~seander/bithacks。html#可积分

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章