Solution to "Sort Integers by The Number of 1 Bits" problem

Author: dkoval

src/main/java/com/github/dkoval/leetcode/challenge/SortIntegersByNumberOf1Bits.java

@@ -0,0 +1,53 @@
+package com.github.dkoval.leetcode.challenge;
+
+import java.util.Arrays;
+
+/**
+ * <a href="https://leetcode.com/problems/sort-integers-by-the-number-of-1-bits/">Sort Integers by The Number of 1 Bits</a>
+ * <p>
+ * You are given an integer array arr. Sort the integers in the array in ascending order by the number of 1's
+ * in their binary representation and in case of two or more integers have the same number of 1's you have to sort them in ascending order.
+ * <p>
+ * Return the array after sorting it.
+ * <p>
+ * Constraints:
+ * <ul>
+ *  <li>1 <= arr.length <= 500</li>
+ *  <li>0 <= arr[i] <= 10^4</li>
+ * </ul>
+ */
+public interface SortIntegersByNumberOf1Bits {
+
+    int[] sortByBits(int[] arr);
+
+    class SortIntegersByNumberOf1BitsRev1 implements SortIntegersByNumberOf1Bits {
+
+        @Override
+        public int[] sortByBits(int[] arr) {
+            final var nums = fromPrimitiveArray(arr);
+            Arrays.sort(nums, (x, y) -> {
+                final var count1 = countBits(x);
+                final var count2 = countBits(y);
+                return (count1 != count2) ? Integer.compare(count1, count2) : Integer.compare(x, y);
+            });
+            return toPrimitiveArray(nums);
+        }
+
+        private Integer[] fromPrimitiveArray(int[] arr) {
+            return Arrays.stream(arr).boxed().toArray(Integer[]::new);
+        }
+
+        private int[] toPrimitiveArray(Integer[] arr) {
+            return Arrays.stream(arr).mapToInt(Integer::intValue).toArray();
+        }
+
+        private int countBits(int x) {
+            var count = 0;
+            while (x > 0) {
+                count += x & 1;
+                x >>= 1;
+            }
+            return count;
+        }
+    }
+}

src/test/kotlin/com/github/dkoval/leetcode/challenge/SortIntegersByNumberOf1BitsTest.kt

@@ -0,0 +1,51 @@
+package com.github.dkoval.leetcode.challenge
+
+import com.github.dkoval.leetcode.challenge.SortIntegersByNumberOf1Bits.SortIntegersByNumberOf1BitsRev1
+import org.junit.jupiter.api.Assertions.assertArrayEquals
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.Arguments.arguments
+import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.provider.ArgumentsSource
+import org.junit.jupiter.params.support.ParameterDeclarations
+import java.util.stream.Stream
+
+internal class SortIntegersByNumberOf1BitsTest {
+
+    class InputArgumentsProvider : ArgumentsProvider {
+
+        override fun provideArguments(
+            parameters: ParameterDeclarations,
+            context: ExtensionContext
+        ): Stream<out Arguments> = Stream.of(
+            arguments(
+                intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8),
+                intArrayOf(0, 1, 2, 4, 8, 3, 5, 6, 7)
+            ),
+            arguments(
+                intArrayOf(1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1),
+                intArrayOf(1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024)
+            )
+        )
+    }
+
+    @Nested
+    inner class SortIntegersByNumberOf1BitsIterTest {
+
+        @ParameterizedTest
+        @ArgumentsSource(InputArgumentsProvider::class)
+        fun `should sort the array by the number of 1 bits in their binary representation`(
+            arr: IntArray,
+            expected: IntArray
+        ) {
+            SortIntegersByNumberOf1BitsRev1().test(arr, expected)
+        }
+    }
+}
+
+private fun SortIntegersByNumberOf1Bits.test(arr: IntArray, expected: IntArray) {
+    val actual = sortByBits(arr)
+    assertArrayEquals(expected, actual)
+}