func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N = N / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N = N / 2
    }
    return binary
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n = n / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n = n / 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    // Write your code here
    var result = ""
    var N = N
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Write your code here
    var result = ""
    var N = N
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    // Write your code here
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Write your code here
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    // Write your code here
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Write your code here
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N = N / 2
    }
    return result
}
<|file_separator|>

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return sum.description
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return sum.description
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    var result = ""
    var num = N
    while num > 0 {
        result = String(num % 2) + result
        num /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var num = N
    while num > 0 {
        result = String(num % 2) + result
        num /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var sum = 0
    var num = N
    while num > 0 {
        sum += num % 2
        num /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    while num > 0 {
        sum += num % 2
        num /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = "\(N % 2)" + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = "\(N % 2)" + result
        N /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = "\(N % 2)" + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = "\(N % 2)" + result
        N /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    // your code goes here
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // your code goes here
}
```

func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = "\(n % 2)" + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    
    while number > 0 {
        let remainder = number % 2
        result = "\(remainder)" + result
        number = number / 2
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    
    while number > 0 {
        let remainder = number % 2
        result = "\(remainder)" + result
        number = number / 2
    }
    
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var result = ""
    var number = N
    while number > 0 {
        result = "\(number % 2)" + result
        number /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }
    
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }
    
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        let digit = number % 10
        sum += digit
        number /= 10
    }
    return String(sum, radix: 2)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        let digit = number % 10
        sum += digit
        number /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        let remainder = number % 2
        binary = "\(remainder)" + binary
        number /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        let remainder = number % 2
        binary = "\(remainder)" + binary
        number /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        let remainder = number % 2
        binary = "\(remainder)" + binary
        number /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        let remainder = number % 2
        binary = "\(remainder)" + binary
        number /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        binary = "\(num % 2)" + binary
        num /= 2
    }
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        binary = "\(num % 2)" + binary
        num /= 2
    }
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var num = N
    while num > 0 {
        let remainder = num % 2
        binary = "\(remainder)" + binary
        num /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        let remainder = number % 2
        binary = "\(remainder)" + binary
        number /= 2
    }
    return binary
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        let remainder = number % 2
        binary = "\(remainder)" + binary
        number /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    let sum = binaryString.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    let sum = binaryString.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    let sum = binaryString.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    let sum = binaryString.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    let sum = binaryString.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    let sum = binaryString.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"

Answer:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    
    

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    
    
    var result = [[Double]()

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    
    
    
    var result = ""
    

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    
    
    
    

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    
    
    
    
    var result = [[Double]
    var result = [[Double]()

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {
    
    
    
    
    var result = [[Double](

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 Given a positive integer N, return the total sum of its digits in binary.
 Example
 Variables:
 @N integer
 Constraints: 0 ≤ N ≤ 10000.
 Output:
 a string of binary number
 solve(N: 1000) == "1"
 solve(N: 150) == "110"
 solve(N: 147) == "1100"
 */
func solve(N: Int) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    if N > 0 && N <= 0, return "0 && N

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var result = ""
    var num = String()
    var num = N = N = N
    while N > 0

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    if N > 0 && N <= 0 || N <= 0 || N

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var result = ""
    var num = 0
    while N > 0
    while N > 0 {
        num = N

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    // Convert the integer to binary representation of the sum of its digits in

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var result = ""
    var num = [String = "1"1"1"
    var digits = N = ""
    while N = N > 0 while N > 0 while N > 0

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = N.toBinaryString()
    return String(binary.map({ String($0) }))
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = N.toBinaryString()
    return String(binary.map({ String($0) }))
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var result = ""
    
    while N > 0 {
        result.insert(String(N % 2), at: 0)
        N /= 2
    }
    
    return result
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var result = ""
    
    while N > 0 {
        result.insert(String(N % 2), at: 0)
        N /= 2
    }
    
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = Int(binary.filter({ $0 == "1" }))?.value ?? 0
    return String(sum)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = Int(binary.filter({ $0 == "1" }))?.value ?? 0
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var result = ""
    
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    
    return result
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var result = ""
    
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var result = ""
    
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    
    return result
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var result = ""
    
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    return String(sum)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N /= 2
    }
    return binaryString
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N /= 2
    }
    return binaryString
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N /= 2
    }
    return binaryString
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N /= 2
    }
    return binaryString
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N = N / 2
    }
    return binaryString
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N = N / 2
    }
    return binaryString
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binary = ""
    while N > 0 {
        binary = String(N % 2) + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var num = N
    var binary = ""
    while num > 0 {
        binary = String(num % 2) + binary
        num /= 2
    }
    return binary
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var num = N
    var binary = ""
    while num > 0 {
        binary = String(num % 2) + binary
        num /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var num = N
    var binarySum = ""
    while num > 0 {
        binarySum = String(num % 2) + binarySum
        num /= 2
    }
    return binarySum
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var num = N
    var binarySum = ""
    while num > 0 {
        binarySum = String(num % 2) + binarySum
        num /= 2
    }
    return binarySum
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N = N / 2
    }
    return binaryString
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var N = N
    var binaryString = ""
    while N > 0 {
        binaryString = String(N % 2) + binaryString
        N = N / 2
    }
    return binaryString
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        if let num = Int(String(digit)) {
            sum += num
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        if let num = Int(String(digit)) {
            sum += num
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binaryString = String(N, radix: 2)
    var sum = 0
    for char in binaryString {
        if let digit = Int(String(char)) {
            sum += digit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(String(digit))!
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(String(digit))!
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        if let intDigit = Int(String(digit)) {
            sum += intDigit
        }
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
import Foundation

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        if let intDigit = Int(String(digit)) {
            sum += intDigit
        }
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var sum = 0
    var temp = N
    while temp > 0 {
        sum += temp % 10
        temp /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    let sum = String(N).compactMap { Int(String($0)) }.reduce(0, +)
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1.description)! }
    return String(sum, radix: 2)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    var binary = ""
    var remainder = N
    while remainder > 0 {
        let remainder = remainder % 2
        binary.insert(String(remainder), at: 0)
        remainder = remainder / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var remainder = N
    while remainder > 0 {
        let remainder = remainder % 2
        binary.insert(String(remainder), at: 0)
        remainder = remainder / 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    var binary = ""
    var remainder = N
    while remainder > 0 {
        let remainder = remainder % 2
        binary = String(format: "%d%@", remainder, binary)
        remainder = remainder / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var remainder = N
    while remainder > 0 {
        let remainder = remainder % 2
        binary = String(format: "%d%@", remainder, binary)
        remainder = remainder / 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result += String(binary[i])
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result += String(binary[i])
    }
    return result
}
```

func solve(N: Int) -> String {
    // Write your code here
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result += String(format: "%c", binary[i])
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Write your code here
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result += String(format: "%c", binary[i])
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result.append(String(format: "%c", binary[i]))
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result.append(String(format: "%c", binary[i]))
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result.append(String(format: "%c", binary[i]))
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result.append(String(format: "%c", binary[i]))
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result.append(String(format: "%c", binary[i]))
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var binary = N.toBinary()
    for i in 0..<binary.count {
        result.append(String(format: "%c", binary[i]))
    }
    return result
}
```

func solve(N: Int) -> String {
    var binary = ""
    var remainder = N
    while remainder > 0 {
        let remainder = remainder % 2
        binary = String(format: "%d%@", remainder, binary)
        remainder = remainder / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var remainder = N
    while remainder > 0 {
        let remainder = remainder % 2
        binary = String(format: "%d%@", remainder, binary)
        remainder = remainder / 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        let digit = n % 2
        n = n / 2
        result = String(format: "%d%@", digit, result)
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        let digit = n % 2
        n = n / 2
        result = String(format: "%d%@", digit, result)
    }
    return result
}
```

func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(format: "%d%@", n % 2, result)
        n = n / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(format: "%d%@", n % 2, result)
        n = n / 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<|im_end|>
<|im_start|>assistant
```swift
func solve(N: Int) -> String {
    var number = N
    var sum = 0
    
    while number > 0 {
        sum += number % 2
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```
### Problem

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    return binary
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var number = N
    while number > 0 {
        binary = String(number % 2) + binary
        number /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```
### Problem

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```
### Problem

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```
### Test

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    return String(binary.reduce(0) { $0 + Int($1.wholeNumberValue ?? 0) })
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    return String(binary.reduce(0) { $0 + Int($1.wholeNumberValue ?? 0) })
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1)! }
    return String(sum)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int($1)! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"
### Response:
```swift
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    // Convert the integer to binary and calculate the sum of its digits
    let binarySum = String(N, radix: 2).reduce(0) { $0 + Int($1.wholeNumberValue!) }
    // Convert the sum to binary and return it
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to binary and calculate the sum of its digits
    let binarySum = String(N, radix: 2).reduce(0) { $0 + Int($1.wholeNumberValue!) }
    // Convert the sum to binary and return it
    return String(binarySum, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    // Convert the integer to its binary representation and remove the '0b' prefix
    let binaryRepresentation = String(N, radix: 2)
    // Calculate the sum of the digits in the binary representation
    let binarySum = binaryRepresentation.reduce(0) { $0 + Int(String($1))! }
    // Convert the sum to binary and return the result
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to its binary representation and remove the '0b' prefix
    let binaryRepresentation = String(N, radix: 2)
    // Calculate the sum of the digits in the binary representation
    let binarySum = binaryRepresentation.reduce(0) { $0 + Int(String($1))! }
    // Convert the sum to binary and return the result
    return String(binarySum, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    var binaryString = ""
    var n = N
    while n > 0 {
        binaryString = String(n % 2) + binaryString
        n /= 2
    }
    return binaryString
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binaryString = ""
    var n = N
    while n > 0 {
        binaryString = String(n % 2) + binaryString
        n /= 2
    }
    return binaryString
}
```

func solve(N: Int) -> String {
    // Convert the integer to binary and then to string
    let binaryString = String(N, radix: 2)
    // Calculate the sum of the digits in binary
    let binarySum = binaryString.reduce(0) { $0 + Int(String($1), radix: 2)! }
    // Convert the sum back to binary and return
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to binary and then to string
    let binaryString = String(N, radix: 2)
    // Calculate the sum of the digits in binary
    let binarySum = binaryString.reduce(0) { $0 + Int(String($1), radix: 2)! }
    // Convert the sum back to binary and return
    return String(binarySum, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    // Convert the integer to binary and then to string
    let binaryString = String(N, radix: 2)
    
    // Calculate the sum of the digits in the binary representation
    let binarySum = binaryString.reduce(0) { $0 + Int(String($1))! }
    
    // Convert the sum back to binary and return the string representation
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to binary and then to string
    let binaryString = String(N, radix: 2)
    
    // Calculate the sum of the digits in the binary representation
    let binarySum = binaryString.reduce(0) { $0 + Int(String($1))! }
    
    // Convert the sum back to binary and return the string representation
    return String(binarySum, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    // Convert the integer to its binary representation
    let binaryString = String(N, radix: 2)
    
    // Calculate the sum of the digits in the binary string
    let binarySum = binaryString.reduce(0) { $0 + Int(String($1))! }
    
    // Convert the sum to binary and return it
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to its binary representation
    let binaryString = String(N, radix: 2)
    
    // Calculate the sum of the digits in the binary string
    let binarySum = binaryString.reduce(0) { $0 + Int(String($1))! }
    
    // Convert the sum to binary and return it
    return String(binarySum, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    // Convert the integer to its binary representation and sum the digits
    let binaryRepresentation = String(N, radix: 2)
    let sumOfDigits = binaryRepresentation.reduce(0) { $0 + Int(String($1), radix: 2)! }
    
    // Convert the sum to binary and return the result
    return String(sumOfDigits, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to its binary representation and sum the digits
    let binaryRepresentation = String(N, radix: 2)
    let sumOfDigits = binaryRepresentation.reduce(0) { $0 + Int(String($1), radix: 2)! }
    
    // Convert the sum to binary and return the result
    return String(sumOfDigits, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    var binarySum = 0
    var num = N
    while num > 0 {
        binarySum += num % 2
        num /= 2
    }
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binarySum = 0
    var num = N
    while num > 0 {
        binarySum += num % 2
        num /= 2
    }
    return String(binarySum, radix: 2)
}
```

func solve(N: Int) -> String {
    // Convert the integer to a string, then to an array of characters, then map each character to its integer value, then reduce the array to a single integer, then convert that integer to a binary string.
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Convert the integer to a string, then to an array of characters, then map each character to its integer value, then reduce the array to a single integer, then convert that integer to a binary string.
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    var binarySum = 0
    var n = N
    while n > 0 {
        binarySum += n % 2
        n /= 2
    }
    return String(binarySum, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binarySum = 0
    var n = N
    while n > 0 {
        binarySum += n % 2
        n /= 2
    }
    return String(binarySum, radix: 2)
}

// Example usage:
print(solve(N: 1000))  // Output: "1"
print(solve(N: 150))   // Output: "110"
print(solve(N: 147))   // Output: "1100"
```

func solve(N: Int) -> String {
    var n = N
    var sum = 0
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var n = N
    var sum = 0
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return sum.description
}
<|file_separator|>```

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>

func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>

func solve(N: Int) -> String {
    // Write your code here
    var N = N
    var result = ""
    while N > 0 {
        result = "\(N % 2)" + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    // Write your code here
    var N = N
    var result = ""
    while N > 0 {
        result = "\(N % 2)" + result
        N = N / 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    var N = N
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>```

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>```

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>```

func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}
<|file_separator|>```

func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var N = N
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return String(sum)
}
<|file_separator|>```

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>```

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = "\(N % 2)" + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = "\(N % 2)" + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary = ""
    var n = N
    while n > 0 {
        binary = String(n % 2) + binary
        n /= 2
    }
    return binary
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    return sum.description
}
<|file_separator|>

func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var N = N
    var result = ""
    while N > 0 {
        result = String(N % 2) + result
        N /= 2
    }
    return result
}
<|file_separator|>

func solve(N: Int) -> String {
    return String(N, radix: 2).compactMap { $0.wholeNumberValue }.reduce(0, +).description
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2).compactMap { $0.wholeNumberValue }.reduce(0, +).description
}
```

func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n = n / 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n = n / 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2).reduce(0) { $0 + Int(String($1))! }
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2).reduce(0) { $0 + Int(String($1))! }
}
```

func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n != 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n != 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for char in binary {
        sum += Int(String(char))!
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n != 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n != 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2)
}
```

func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    var sum = 0
    var num = N
    while num > 0 {
        sum += num % 2
        num /= 2
    }
    return String(sum)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    while num > 0 {
        sum += num % 2
        num /= 2
    }
    return String(sum)
}
```

func solve(N: Int) -> String {
    return String(N, radix: 2).map{ String($0) }.reduce(0, { $0 + Int($1)! })
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    return String(N, radix: 2).map{ String($0) }.reduce(0, { $0 + Int($1)! })
}
```

func solve(N: Int) -> String {
    var sum = 0
    var num = N
    while num > 0 {
        sum += num % 2
        num = num / 2
    }
    return sum.toString(radix: 2)
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    while num > 0 {
        sum += num % 2
        num = num / 2
    }
    return sum.toString(radix: 2)
}

```

func solve(N: Int) -> String {
    var binaryString = ""
    var remainder = N
    while remainder > 0 {
        binaryString = string(remainder % 2) + binaryString
        remainder = remainder / 2
    }
    return binaryString
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binaryString = ""
    var remainder = N
    while remainder > 0 {
        binaryString = string(remainder % 2) + binaryString
        remainder = remainder / 2
    }
    return binaryString
}
```

func solve(N: Int) -> String {
    var binary: String = ""
    var remainder: Int = 0
    while N > 0 {
        remainder = N % 2
        binary = binary + (remainder).String()
        N = N / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary: String = ""
    var remainder: Int = 0
    while N > 0 {
        remainder = N % 2
        binary = binary + (remainder).String()
        N = N / 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    var sum: Int = 0
    var binary: String = ""
    while N > 0 {
        sum += N % 2
        N = N / 2
    }
    while sum > 0 {
        binary = string(sum % 2) + binary
        sum = sum / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum: Int = 0
    var binary: String = ""
    while N > 0 {
        sum += N % 2
        N = N / 2
    }
    while sum > 0 {
        binary = string(sum % 2) + binary
        sum = sum / 2
    }
    return binary
}

```

func solve(N: Int) -> String {
    var binaryString = ""
    var currentNumber = N
    while currentNumber > 0 {
        binaryString = string(currentNumber % 2) + binaryString
        currentNumber = currentNumber / 2
    }
    return binaryString
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binaryString = ""
    var currentNumber = N
    while currentNumber > 0 {
        binaryString = string(currentNumber % 2) + binaryString
        currentNumber = currentNumber / 2
    }
    return binaryString
}
```

func solve(N: Int) -> String {
    var sum = 0
    var result = ""
    while N > 0 {
        sum += N % 2
        N = N / 2
    }
    while sum > 0 {
        result = result + (sum % 2).toString()
        sum = sum / 2
    }
    return result.reversed()
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var result = ""
    while N > 0 {
        sum += N % 2
        N = N / 2
    }
    while sum > 0 {
        result = result + (sum % 2).toString()
        sum = sum / 2
    }
    return result.reversed()
}
```

func solve(N: Int) -> String {
    var binary: String = ""
    var n: Int = N
    while n > 0 {
        binary = (n % 2).toString() + binary
        n = n / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary: String = ""
    var n: Int = N
    while n > 0 {
        binary = (n % 2).toString() + binary
        n = n / 2
    }
    return binary
}
```

func solve(N: Int) -> String {
    var sum = 0
    var binary = ""
    while N > 0 {
        sum += N % 2
        N = N / 2
        binary = binary + (N % 2).toString()
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var sum = 0
    var binary = ""
    while N > 0 {
        sum += N % 2
        N = N / 2
        binary = binary + (N % 2).toString()
    }
    return binary
}
```

func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var result = ""
    while N > 0 {
        result = string(N % 2) + result
        N = N / 2
    }
    return result
}

//

func solve(N: Int) -> String {
    var binary: String = ""
    var temp: Int = N
    while temp > 0 {
        binary = (temp % 2).toString() + binary
        temp = temp / 2
    }
    return binary
}

```swift
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
// solve(N: 1000) == "1"
// solve(N: 150) == "110"
// solve(N: 147) == "1100"
func solve(N: Int) -> String {
    var binary: String = ""
    var temp: Int = N
    while temp > 0 {
        binary = (temp % 2).toString() + binary
        temp = temp / 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return sum.description
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return sum.description
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    var result = ""
    
    while sum > 0 {
        let digit = sum % 2
        result = "\(digit)" + result
        sum /= 2
    }
    
    return result.isEmpty ? "0" : result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    var result = ""
    
    while sum > 0 {
        let digit = sum % 2
        result = "\(digit)" + result
        sum /= 2
    }
    
    return result.isEmpty ? "0" : result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    var binarySum = ""
    
    while sum > 0 {
        let remainder = sum % 2
        binarySum = "\(remainder)" + binarySum
        sum /= 2
    }
    
    return binarySum.isEmpty ? "0" : binarySum
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    var binarySum = ""
    
    while sum > 0 {
        let remainder = sum % 2
        binarySum = "\(remainder)" + binarySum
        sum /= 2
    }
    
    return binarySum.isEmpty ? "0" : binarySum
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    var binarySum = ""
    
    while sum > 0 {
        let digit = sum % 2
        binarySum = "\(digit)" + binarySum
        sum /= 2
    }
    
    return binarySum.isEmpty ? "0" : binarySum
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    var binarySum = ""
    
    while sum > 0 {
        let digit = sum % 2
        binarySum = "\(digit)" + binarySum
        sum /= 2
    }
    
    return binarySum.isEmpty ? "0" : binarySum
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    var result = ""
    while sum > 0 {
        let digit = sum % 2
        result = "\(digit)" + result
        sum /= 2
    }
    
    return result.isEmpty ? "0" : result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var num = N
    
    while num > 0 {
        let digit = num % 2
        sum += digit
        num /= 2
    }
    
    var result = ""
    while sum > 0 {
        let digit = sum % 2
        result = "\(digit)" + result
        sum /= 2
    }
    
    return result.isEmpty ? "0" : result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    
    return String(sum)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    
    return String(sum)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N

    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }

    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N

    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }

    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    
    while n > 0 {
        let digit = n % 2
        sum += digit
        n /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N
    
    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }
    
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N

    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }

    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N

    while number > 0 {
        let remainder = number % 2
        sum += remainder
        number /= 2
    }

    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 2
        n /= 2
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N

    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }

    return String(sum, radix: 2)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100"<end_of_turn>
<start_of_turn>model
```swift
func solve(N: Int) -> String {
    var sum = 0
    var number = N

    while number > 0 {
        let digit = number % 2
        sum += digit
        number /= 2
    }

    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    let sum = binary.reduce(0) { $0 + Int(String($1))! }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    let binary = String(N, radix: 2)
    var sum = 0
    for digit in binary {
        sum += Int(digit.wholeNumberValue!)
    }
    return String(sum)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var result = ""
    var n = N
    while n > 0 {
        result = String(n % 2) + result
        n /= 2
    }
    return result
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 2
        sum += digit
        binary = digit.description + binary
        N /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 2
        sum += digit
        binary = digit.description + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 2
        sum += digit
        binary = digit.description + binary
        N /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 2
        sum += digit
        binary = digit.description + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 2
        sum += digit
        binary = digit.description + binary
        N /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 2
        sum += digit
        binary = digit.description + binary
        N /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 10
        sum += digit
        binary = "\(digit)" + binary
        N /= 10
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        let digit = N % 10
        sum += digit
        binary = "\(digit)" + binary
        N /= 10
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 10
        N /= 10
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binaryString = ""
    var currentDigit = N
    while currentDigit > 0 {
        let remainder = currentDigit % 2
        binaryString = "\(remainder)" + binaryString
        currentDigit /= 2
    }
    return binaryString
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binaryString = ""
    var currentDigit = N
    while currentDigit > 0 {
        let remainder = currentDigit % 2
        binaryString = "\(remainder)" + binaryString
        currentDigit /= 2
    }
    return binaryString
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var binary = ""
    var sum = 0
    while N > 0 {
        sum += N % 2
        N /= 2
    }
    while sum > 0 {
        binary = String(sum % 2) + binary
        sum /= 2
    }
    return binary
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```

@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given a positive integer N, return the total sum of its digits in binary.
Example
Variables:
@N integer
Constraints: 0 ≤ N ≤ 10000.
Output:
a string of binary number
solve(N: 1000) == "1"
solve(N: 150) == "110"
solve(N: 147) == "1100" [/INST] ```swift
func solve(N: Int) -> String {
    var sum = 0
    var n = N
    while n > 0 {
        sum += n % 10
        n /= 10
    }
    return String(sum, radix: 2)
}
```