Day 10

Author: geekayush

.gitignore

@@ -1,3 +1,4 @@
 .codelite/
 Competitive.workspace
-Makefile
+Makefile
+.vscode/

Day10-BinaryNumbers/C++/main.cpp

@@ -0,0 +1,34 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main()
+{
+    int maxCount = 0;
+    int count = 0;
+    int n;
+    cin >> n;
+    cin.ignore(numeric_limits<streamsize>::max(), '\n');
+    vector<int> binary;
+    vector<int>::iterator itr;
+    while (n)
+    {
+        binary.insert(binary.begin(), n % 2);
+        n /= 2;
+    }
+    for (itr = binary.begin(); itr != binary.end(); itr++)
+    {
+        if (*itr == 1)
+        {
+            count += 1;
+        }
+        else
+            count = 0;
+        if (count > maxCount)
+        {
+            maxCount = count;
+        }
+    }
+    cout << maxCount;
+    return 0;
+}

Day10-BinaryNumbers/Java/main.java

@@ -0,0 +1,41 @@
+import java.util.*;
+
+public class Solution {
+    public static int mostConsecutiveOnes(int n) {
+        // convert number->binary string->char array
+        char[] binary = Integer.toBinaryString(n).toCharArray();
+        
+        // count of current sequence of consecutive ones
+        int tmpCount = 0; 
+        
+        // running maximum count of consecutive ones for any section to left of tmpCount
+        int maxCount = 0; 
+        for(int i = 0; i < binary.length; i++){
+            
+            // reset to 0 if we hit a '0' char
+            if(binary[i] == '0') {
+                
+                // set new max if needed
+                if(tmpCount > maxCount){
+                    maxCount = tmpCount;
+                }
+                    
+                tmpCount = 0;
+            }
+            else { // current location is a section of consecutive 1's
+                // increment tmpCount
+                tmpCount =  tmpCount + 1; 
+            }
+        }
+        // conditional is necessary here in case the string does not end with a 0
+        return (tmpCount > maxCount) ? tmpCount : maxCount;
+    }
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int n = scan.nextInt();
+        scan.close();
+
+        System.out.println(mostConsecutiveOnes(n));
+    }
+}

Day10-BinaryNumbers/README.md

@@ -0,0 +1,48 @@
+## Objective 
+Today, we're working with binary numbers.
+
+## Task 
+Given a base-10 integer, n, convert it to binary (base-2). Then find and print the base-10 integer denoting the maximum number of consecutive 1's in n's binary representation.
+
+## Input Format
+```
+A single integer, n.
+```
+
+## Constraints
+<code>
+1<=n<=10<sup>6</sup>
+</code>
+
+## Output Format
+```
+Print a single base-10 integer denoting the maximum number of consecutive 1's in the binary representation of n.
+```
+
+## Sample Input 1
+```
+5
+```
+
+## Sample Output 1
+```
+1
+```
+
+## Sample Input 2
+```
+13
+```
+
+## Sample Output 2
+```
+2
+```
+
+## Explanation
+
+Sample Case 1: 
+The binary representation of 5 is 101, so the maximum number of consecutive 1's is 1.
+
+Sample Case 2: 
+The binary representation of 13 is 1101, so the maximum number of consecutive 1's is 2.

README.md

@@ -16,6 +16,7 @@ The repository covers all the basic topics of programming languages. Try a new c
 - [Day 7 - Arrays](https://github.com/geekayush/30daysofcode/tree/master/Day7-Arrays)
 - [Day 8 - Dictionaries&Maps](https://github.com/geekayush/30daysofcode/tree/master/Day8-Dictionaries&Maps)
 - [Day 9 - Recursion](https://github.com/geekayush/30daysofcode/tree/master/Day9-Recursion)
+- [Day 10 - Binary Numbers](https://github.com/geekayush/30daysofcode/tree/master/Day10-BinaryNumbers)
 
 ##### How to contribute?