Сгенерировать целочисленное двоичное представление с помощью Swift?

Ответ 1

String имеет конструкторы

init<T : _SignedIntegerType>(_ v: T, radix: Int, uppercase: Bool = default)
init<T : _UnsignedIntegerType>(_ v: T, radix: Int, uppercase: Bool = default)

который можно использовать здесь:

let num = 100
let str = String(num, radix: 2)
print(str)
// Output: 1100100

Ответ 2

Здесь немного более короткая версия. Однако он не добавляет лишних ведущих нолей:

func bitRep<T: IntegerArithmeticType>(value: T) -> String {
    var n: IntMax = value.toIntMax()
    var rep = ""
    while(n > 0){
        rep += "\(n % 2)"
        n = n / 2;
    }
    return rep
}

Ответ 3

let binStr:Int->String = {a in return String(a, radix: 2)}
binStr(7) // "111"

Ответ 4

Здесь используется функция, использующая Generics для принятия любого типа Int или Uint без преобразования param.

1- Функция должна ограничивать тип значения, соответствующий протоколу "ToInt" чтобы предложить уникальный метод преобразования типа self в Int

2- Функция вычисляет потребности в битах длины относительно типа параметра

3- Функция вставляет пробел каждые 8 ​​цифр, чтобы обеспечить удобочитаемость

protocol ToInt { func toInt() -> Int }

extension UInt: ToInt { func toInt() -> Int { return Int(self) } }
extension Int8: ToInt { func toInt() -> Int { return Int(self) } }
extension UInt8: ToInt { func toInt() -> Int { return Int(self) } }
extension Int16: ToInt { func toInt() -> Int { return Int(self) } }
extension UInt16: ToInt { func toInt() -> Int { return Int(self) } }
extension Int32: ToInt { func toInt() -> Int { return Int(self) } }
extension UInt32: ToInt { func toInt() -> Int { return Int(self) } }
extension Int64: ToInt { func toInt() -> Int { return Int(self) } }
extension UInt64: ToInt { func toInt() -> Int { return Int(self) } }

func bitRep<T:ToInt>(value: T) -> String {
    var size: Int
    switch value {
    case is Int8, is UInt8: size = 7
    case is Int16, is UInt16: size = 15
    case is Int32, is UInt32: size = 31
    case is Int64, is UInt64: size = 63
    default : size = 63
    }
    var n = value.toInt()
    var rep = ""
    for (var c = size; c >= 0; c--) {
       var k = n >> c
       if (k & 1) == 1 { rep += "1" } else { rep += "0" }
       if c%8 == 0 && c != 0 { rep += " " }
    }
    return rep
}

Некоторые примеры:

let b1: UInt8 = 0b00000000
bitRep(b1)

// > "00000000"

let c1: UInt16 = 0b00000000_10000101
bitRep(c1)

// > "00000000 10000101"

let e1: UInt64 = 0b00000000_00000000_00000000_00000001
bitRep(e1)

// > "00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001"

и т.д.

(algo, вдохновленный этой нитью: Превращение целого в его двоичное представление с использованием C?)