Maximum Possible Number by Binary Concatenation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Solution {
public:
    int maximumBinaryNumber(vector<int>& nums) {
        int ans = 0;
        sort(nums.begin(), nums.end());
        do {
            string s;
            for (int x : nums) s += bitset<32>(x).to_string().substr(bitset<32>(x).to_string().find('1'));
            ans = max(ans, (int)stoll(s, nullptr, 2));
        } while (next_permutation(nums.begin(), nums.end()));
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import "strconv"
func maximumBinaryNumber(nums []int) int {
    ans := 0
    perm := func(a []int, f func([]int)) {
        var generate func(int)
        generate = func(n int) {
            if n == 1 {
                tmp := make([]int, len(a))
                copy(tmp, a)
                f(tmp)
                return
            }
            for i := 0; i < n; i++ {
                generate(n-1)
                if n%2 == 1 {
                    a[0], a[n-1] = a[n-1], a[0]
                } else {
                    a[i], a[n-1] = a[n-1], a[i]
                }
            }
        }
        generate(len(a))
    }
    perm(nums, func(p []int) {
        s := ""
        for _, x := range p {
            b := strconv.FormatInt(int64(x), 2)
            s += b
        }
        v, _ := strconv.ParseInt(s, 2, 64)
        if int(v) > ans {
            ans = int(v)
        }
    })
    return ans
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Solution {
    public int maximumBinaryNumber(int[] nums) {
        int ans = 0;
        List<Integer> list = new ArrayList<>();
        for (int x : nums) list.add(x);
        Collections.sort(list);
        do {
            StringBuilder sb = new StringBuilder();
            for (int x : list) sb.append(Integer.toBinaryString(x));
            int v = Integer.parseUnsignedInt(sb.toString(), 2);
            ans = Math.max(ans, v);
        } while (nextPermutation(list));
        return ans;
    }
    private boolean nextPermutation(List<Integer> nums) {
        int i = nums.size() - 2;
        while (i >= 0 && nums.get(i) >= nums.get(i+1)) i--;
        if (i < 0) return false;
        int j = nums.size() - 1;
        while (nums.get(j) <= nums.get(i)) j--;
        Collections.swap(nums, i, j);
        Collections.reverse(nums.subList(i+1, nums.size()));
        return true;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class Solution {
    fun maximumBinaryNumber(nums: IntArray): Int {
        var ans = 0
        fun nextPermutation(a: IntArray): Boolean {
            var i = a.size - 2
            while (i >= 0 && a[i] >= a[i+1]) i--
            if (i < 0) return false
            var j = a.size - 1
            while (a[j] <= a[i]) j--
            a[i] = a[j].also { a[j] = a[i] }
            a.reverse(i+1, a.size)
            return true
        }
        nums.sort()
        do {
            val s = nums.joinToString(separator = "") { it.toString(2) }
            val v = s.toInt(2)
            ans = maxOf(ans, v)
        } while (nextPermutation(nums))
        return ans
    }
    private fun IntArray.reverse(from: Int, to: Int) {
        var l = from
        var r = to - 1
        while (l < r) {
            this[l] = this[r].also { this[r] = this[l] }
            l++
            r--
        }
    }
}

1
2
3
4
5
6
7
8

from itertools import permutations
class Solution:
    def maximumBinaryNumber(self, nums: list[int]) -> int:
        ans = 0
        for p in permutations(nums):
            s = ''.join(bin(x)[2:] for x in p)
            ans = max(ans, int(s, 2))
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

impl Solution {
    pub fn maximum_binary_number(nums: Vec<i32>) -> i32 {
        let mut ans = 0;
        let mut arr = nums.clone();
        arr.sort();
        loop {
            let s: String = arr.iter().map(|&x| format!("{:b}", x)).collect();
            let v = i32::from_str_radix(&s, 2).unwrap();
            ans = ans.max(v);
            if !next_permutation(&mut arr) { break; }
        }
        ans
    }
}
fn next_permutation(nums: &mut [i32]) -> bool {
    let n = nums.len();
    if n < 2 { return false; }
    let mut i = n - 2;
    while i != usize::MAX && nums[i] >= nums[i+1] { if i == 0 { break; } i -= 1; }
    if nums[i] >= nums[i+1] { return false; }
    let mut j = n - 1;
    while nums[j] <= nums[i] { j -= 1; }
    nums.swap(i, j);
    nums[i+1..].reverse();
    true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class Solution {
    maximumBinaryNumber(nums: number[]): number {
        let ans = 0;
        const permute = (arr: number[], l: number) => {
            if (l === arr.length) {
                const s = arr.map(x => x.toString(2)).join("");
                const v = parseInt(s, 2);
                ans = Math.max(ans, v);
                return;
            }
            for (let i = l; i < arr.length; ++i) {
                [arr[l], arr[i]] = [arr[i], arr[l]];
                permute(arr, l+1);
                [arr[l], arr[i]] = [arr[i], arr[l]];
            }
        };
        permute(nums, 0);
        return ans;
    }
}