Merge pull request #356 from sir-gon/feature/flipping_bits

[Hacker Rank] Interview Preparation Kit: Miscellaneous: Flipping bits…

Author: sir-gon

docs/hackerrank/interview_preparation_kit/miscellaneous/flipping-bits.md

@@ -0,0 +1,120 @@
+# [Miscellaneous: Flipping bits](https://www.hackerrank.com/challenges/flipping-bits)
+
+- Difficulty:  `#easy`
+- Category: `#ProblemSolvingBasic` `#BitManipulation`
+
+You will be given a list of 32 bit unsigned integers.
+Flip all the bits ( `1 -> 0` and `0 -> 1`)
+and return the result as an unsigned integer.
+
+## Example
+
+$ n = 9_{10} $. We're working with 32 bits, so:
+
+$ 9_{10} = 1001_{2} $
+
+$ 00000000000000000000000000001001_{2} = 9_{10} $
+$ 11111111111111111111111111110110_{2} = 4294967286_{10} $
+
+Return `4294967286`
+
+## Function Description
+
+Complete the flippingBits function in the editor below.
+
+flippingBits has the following parameter(s):
+
+- `int n`: an integer
+
+## Returns
+
+- `int`: the unsigned decimal integer result
+
+## Input Format
+
+The first line of the input contains `q`, the number of queries.
+Each of the next `q` lines contain an integer, `n`, to process.
+
+## Constraints
+
+- $ 1 \leq q \leq 100 $
+- $ 0 \leq n \leq 2^{32} $
+
+## Sample Input 0
+
+```text
+3
+2147483647
+1
+0
+```
+
+## Sample Output 0
+
+```text
+2147483648
+4294967294
+4294967295
+```
+
+## Explanation 0
+
+$ 01111111111111111111111111111111_{2} = 2147483647_{10} $
+$ 10000000000000000000000000000000_{2} = 2147483648_{10} $
+
+$ 00000000000000000000000000000001_{2} = 1_{10} $
+$ 11111111111111111111111111111110_{2} = 4294967294_{10} $
+
+$ 00000000000000000000000000000000_{2} = 0_{10} $
+$ 11111111111111111111111111111110_{2} = 4294967295_{10} $
+
+## Sample Input 1
+
+```text
+2
+4
+123456
+```
+
+## Sample Output 1
+
+```text
+4294967291
+4294843839
+```
+
+## Explanation 1
+
+$ 00000000000000000000000000000100_{2} = 4_{10} $
+$ 11111111111111111111111111111011_{2} = 4294967291_{10} $
+
+$ 00000000000000011110001001000000_{2} = 4_{10} $
+$ 11111111111111100001110110111111_{2} = 429484389_{10} $
+
+## Sample Input 2
+
+```text
+3
+0
+802743475
+35601423
+```
+
+## Sample Output 2
+
+```text
+4294967295
+3492223820
+4259365872
+```
+
+## Explanation 2
+
+$ 00000000000000000000000000000000_{2} = 4_{10} $
+$ 11111111111111111111111111111111_{2} = 4294967295_{10} $
+
+$ 00101111110110001110010010110011_{2} = 802743475_{10} $
+$ 11010000001001110001101101001100_{2} = 3492223820_{10} $
+
+$ 00000010000111110011110000001111_{2} = 35601423_{10} $
+$ 11111101111000001100001111110000_{2} = 4259365872_{10} $

exercises/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits.go

@@ -0,0 +1,13 @@
+/**
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/miscellaneous/flipping-bits.md]]
+ */
+
+package hackerrank
+
+func flippingBits(n int64) int64 {
+	return ^n & 0xFFFFFFFF // Flip all bits and mask to 32 bits
+}
+
+func FlippingBits(n int64) int64 {
+	return flippingBits(n)
+}

exercises/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits.testcases.json

@@ -0,0 +1,49 @@
+[
+  {
+    "title": "Sample Test Case 0",
+    "tests": [
+      {
+        "input": 2147483647,
+        "answer": 2147483648
+      },
+      {
+        "input": 1,
+        "answer": 4294967294
+      },
+      {
+        "input": 0,
+        "answer": 4294967295
+      }
+    ]
+  },
+  {
+    "title": "Sample Test Case 1",
+    "tests": [
+      {
+        "input": 4,
+        "answer": 4294967291
+      },
+      {
+        "input": 123456,
+        "answer": 4294843839
+      }
+    ]
+  },
+  {
+    "title": "Sample Test Case 2",
+    "tests": [
+      {
+        "input": 0,
+        "answer": 4294967295
+      },
+      {
+        "input": 802743475,
+        "answer": 3492223820
+      },
+      {
+        "input": 35601423,
+        "answer": 4259365872
+      }
+    ]
+  }
+]

exercises/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits_test.go

@@ -0,0 +1,50 @@
+package hackerrank
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gon.cl/algorithms/utils"
+)
+
+type FlipingBitsTest struct {
+	Input    int64 `json:"input"`
+	Expected int64 `json:"answer"`
+}
+
+type FlipingBitsTests struct {
+	Title string            `json:"title"`
+	Tests []FlipingBitsTest `json:"tests"`
+}
+
+var FlipingBitsTestCases []FlipingBitsTests
+
+// You can use testing.T, if you want to test the code without benchmarking
+func FlipingBitsSetupSuite(t testing.TB) {
+	wd, _ := os.Getwd()
+	filepath := wd + "/flipping_bits.testcases.json"
+	t.Log("Setup test cases from JSON: ", filepath)
+
+	var _, err = utils.LoadJSON(filepath, &FlipingBitsTestCases)
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func TestFlipingBits(t *testing.T) {
+
+	FlipingBitsSetupSuite(t)
+
+	for _, tt := range FlipingBitsTestCases {
+		for _, testCase := range tt.Tests {
+			testname := fmt.Sprintf("FlipingBits(%d) => %d \n", testCase.Input, testCase.Expected)
+
+			t.Run(testname, func(t *testing.T) {
+				ans := FlippingBits(testCase.Input)
+				assert.Equal(t, testCase.Expected, ans)
+			})
+		}
+	}
+}