检查数字是否有交替模式的位|设置1-yiteyi-C++库

给定一个n>0的整数，任务是找出该整数在其位表示中是否有替代模式。例如-5有一个替代模式，即101。如果有替代图案，则打印“是”，否则打印“否”。这里的替代模式可以是0101或1010。

null

例如：

Input :  15Output :  NoExplanation: Binary representation of 15 is 1111.Input :  10Output :  YesExplanation: Binary representation of 10 is 1010.

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

一种简单的方法是找到它的二进制等价物，然后检查它的位。

C++

                         // C++ program to find if a number has alternate                       
                         // bit pattern                       
                         #include<bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Returns true if n has alternate bit pattern                       
                         // else false                       
                         bool                                     findPattern(                                     int                                     n)                       
                         {                       
                                                 // Store last bit                       
                                                 int                                     prev = n % 2;                       
                                                 n = n/2;                       
           
                                                 // Traverse through remaining bits                       
                                                 while                                     (n > 0)                       
                                                 {                       
                                                 int                                     curr = n % 2;                       
           
                                                 // If current bit is same as previous                       
                                                 if                                     (curr == prev)                       
                                                 return                                     false                                     ;                       
           
                                                 prev = curr;                       
                                                 n = n / 2;                       
                                                 }                       
           
                                                 return                                     true                                     ;                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = 10;                       
                                                 if                                     (findPattern(n))                       
                                                 cout <<                                     "Yes"                                     ;                       
                                                 else                       
                                                 cout <<                                     "No"                                     ;                       
           
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to find if a number has alternate                       
                         // bit pattern                       
           
                         class                                     Test                       
                         {                       
                                                 // Returns true if n has alternate bit pattern                       
                                                 // else false                       
                                                 static                                     boolean                                     findPattern(                                     int                                     n)                       
                                                 {                       
                                                 // Store last bit                       
                                                 int                                     prev = n %                                     2                                     ;                       
                                                 n = n/                                     2                                     ;                       
                                   
                                                 // Traverse through remaining bits                       
                                                 while                                     (n >                                     0                                     )                       
                                                 {                       
                                                 int                                     curr = n %                                     2                                     ;                       
                                   
                                                 // If current bit is same as previous                       
                                                 if                                     (curr == prev)                       
                                                 return                                     false                                     ;                       
                                   
                                                 prev = curr;                       
                                                 n = n /                                     2                                     ;                       
                                                 }                       
                                   
                                                 return                                     true                                     ;                       
                                                 }                       
                                   
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 int                                     n =                                     10                                     ;                       
                                                 System.out.println(findPattern(n) ?                                     "Yes"                                     :                                     "No"                                     );                       
                                   
                                                 }                       
                         }                       

Python3

                         # Python3 program to find if a number                       
                         # has alternate bit pattern                       
           
                         # Returns true if n has alternate                       
                         # bit pattern else false                       
                         def                                     findPattern(n):                       
           
                                                 # Store last bit                       
                                                 prev                                     =                                     n                                     %                                     2                       
                                                 n                                     =                                     n                                     /                                     /                                     2                       
           
                                                 # Traverse through remaining bits                       
                                                 while                                     (n >                                     0                                     ):                       
                                   
                                                 curr                                     =                                     n                                     %                                     2                       
           
                                                 # If current bit is same as previous                       
                                                 if                                     (curr                                     =                                     =                                     prev):                       
                                                 return                                     False                       
           
                                                 prev                                     =                                     curr                       
                                                 n                                     =                                     n                                     /                                     /                                     2                       
                                   
                                                 return                                     True                       
           
                         # Driver code                       
                         n                                     =                                     10                       
                         print                                     (                                     "Yes"                                     )                                     if                                     (findPattern(n))                                     else                                     print                                     (                                     "No"                                     )                       
           
                         # This code is contributed by Anant Agarwal.                       

C#

                         // Program to find if a number                       
                         // has alternate bit pattern                       
                         using                                     System;                       
           
                         class                                     Test {                       
           
                                                 // Returns true if n has alternate                       
                                                 // bit pattern else returns false                       
                                                 static                                     bool                                     findPattern(                                     int                                     n)                       
                                                 {                       
                                                 // Store last bit                       
                                                 int                                     prev = n % 2;                       
                                                 n = n / 2;                       
           
                                                 // Traverse through remaining bits                       
                                                 while                                     (n > 0) {                       
                                                 int                                     curr = n % 2;                       
           
                                                 // If current bit is same as previous                       
                                                 if                                     (curr == prev)                       
                                                 return                                     false                                     ;                       
           
                                                 prev = curr;                       
                                                 n = n / 2;                       
                                                 }                       
           
                                                 return                                     true                                     ;                       
                                                 }                       
           
                                                 // Driver method                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     n = 10;                       
                                                 Console.WriteLine(findPattern(n) ?                                     "Yes"                                     :                                     "No"                                     );                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Anant Agarwal.                       

PHP

                         <?php                       
                         // PHP program to find if a                       
                         // number has alternate                       
                         // bit pattern                       
           
                         // Returns true if n has                       
                         // alternate bit pattern                       
                         // else false                       
                         function                                     findPattern(                                     $n                                     )                       
                         {                       
                                   
                                                 // Store last bit                       
                                                 $prev                                     =                                     $n                                     % 2;                       
                                                 $n                                     =                                     $n                                     / 2;                       
           
                                                 // Traverse through                       
                                                 // remaining bits                       
                                                 while                                     (                                     $n                                     > 0)                       
                                                 {                       
                                                 $curr                                     =                                     $n                                     % 2;                       
           
                                                 // If current bit is                       
                                                 // same as previous                       
                                                 if                                     (                                     $curr                                     ==                                     $prev                                     )                       
                                                 return                                     false;                       
           
                                                 $prev                                     =                                     $curr                                     ;                       
                                                 $n                                     =                                     floor                                     (                                     $n                                     / 2);                       
                                                 }                       
           
                                                 return                                     true;                       
                         }                       
           
                                                 // Driver code                       
                                                 $n                                     = 10;                       
                                                 if                                     (findPattern(                                     $n                                     ))                       
                                                 echo                                     "Yes"                                     ;                       
                                                 else                       
                                                 echo                                     "No"                                     ;                       
                                   
                                                 return                                     0;                       
           
                         // This code is contributed by nitin mittal.                       
                         ?>                       

Javascript

                         <script>                       
           
                         // Javascript program to find if a number                       
                         // has alternate bit pattern                       
           
                         // Returns true if n has alternate                       
                         // bit pattern else false                       
                         function                                     findPattern(n)                       
                         {                       
                                   
                                                 // Store last bit                       
                                                 let prev = n % 2;                       
                                                 n = Math.floor(n / 2);                       
           
                                                 // Traverse through remaining bits                       
                                                 while                                     (n > 0)                       
                                                 {                       
                                                 let curr = n % 2;                       
           
                                                 // If current bit is                       
                                                 // same as previous                       
                                                 if                                     (curr == prev)                       
                                                 return                                     false                                     ;                       
           
                                                 prev = curr;                       
                                                 n = Math.floor(n / 2);                       
                                                 }                       
                                                 return                                     true                                     ;                       
                         }                       
           
                         // Driver code                       
                         let n = 10;                       
                         if                                     (findPattern(n))                       
                                                 document.write(                                     "Yes"                                     );                       
                         else                       
                                                 document.write(                                     "No"                                     );                       
                                   
                         // This code is contributed by gfgking                       
           
                         </script>                       

输出：

Yes

时间复杂性： O（原木） _2. n）

辅助空间： O（1）

参考： http://stackoverflow.com/questions/38690278/program-to-check-whether-the-given-integer-has-an-alternate-pattern

本文由 萨希尔·查布拉（阿克库） .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

技术文章