```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = value.replacingOccurrences(of: ".", with: "")
    let value = value.replacingOccurrences(of: ",", with: "")
    let value = value.replacingOccurrences(of: " ", with: "")
    let value = value.replacingOccurrences(of: "-", with: "")
    let value = value.replacingOccurrences(of: "+", with: "")
    let value = value.replacingOccurrences(of: "0", with: "")
    let value = value.replacingOccurrences(of: "1", with: "")
    let value = value.replacingOccurrences(of: "2", with: "")
    let value = value.replacingOccurrences(of: "3", with: "")
    let value = value.replacingOccurrences(of: "4", with: "")
    let value = value.replacingOccurrences(of: "5", with: "")
    let value = value.replacingOccurrences(of: "6", with: "")
    let value = value.replacingOccurrences(of: "7", with: "")
    let value = value.replacingOccurrences(of: "8", with: "")
    let value = value.replacingOccurrences(of: "9", with: "")
    let value = value.replacingOccurrences(of: "0", with: "")
    let value = value.replacingOccurrences(of: "1", with: "")
    let value = value.replacingOccurrences(of: "2", with: "")
    let value = value.replacingOccurrences(of: "3", with: "")
    let value = value.replacingOccurrences(of: "4", with: "")
    let value = value.replacingOccurrences(of: "5", with: "")
    let value = value.replacingOccurrences(of: "6", with: "")
    let value = value.replacingOccurrences(of: "7", with: "")
    let value = value.replacingOccurrences(of: "8", with: "")
    let value = value.replacingOccurrences(of: "9", with: "")
    let value = value.replacingOccurrences(of: "0", with: "")
    let value = value.replacingOccurrences(of: "1", with: "")
    let value = value.replacingOccurrences(of: "2", with: "")
    let value = value.replacingOccurrences(of: "3", with: "")
    let value = value.replacingOccurrences(of: "4", with: "")
    let value = value.replacingOccurrences(of: "5", with: "")
    let value = value.replacingOccurrences(of: "6", with: "")
    let value = value.replacingOccurrences(of: "7", with: "")
    let value = value.replacingOccurrences(of: "8", with: "")
    let value = value.replacingOccurrences(of: "9", with: "")
    let value = value.replacingOccurrences(of: "0", with: "")
    let value = value.replacingOccurrences(of: "1", with: "")
    let value = value.replacingOccurrences(of: "2", with: "")
    let value = value.replacingOccurrences(of: "3", with: "")
    let value = value.replacingOccurrences(of: "4", with: "")
    let value = value.replacingOccurrences(of: "5", with: "")
    let value = value.replacingOccurrences(of: "6", with: "")
    let value = value.replacingOccurrences(of: "7", with: "")
    let value = value.replacingOccurrences(of: "8", with: "")
    let value = value.replacingOccurrences(of: "9", with: "")
    let value = value.replacingOccurrences(of: "0", with: "")
    let value = value.replacingOccurrences(of: "1", with: "")
    let value = value.replacingOccurrences(of: "2", with: "")
    let value = value.replacingOccurrences(of: "3", with: "")
    let value = value.replacingOccurrences(of: "4", with: "")
    let value = value.replacingOccurrences(of: "5", with: "")
    let value = value.replacingOccurrences(of: "6", with: "")
    let value = value.replacingOccurrences(of: "7", with: "")
    let value = value.replacingOccurrences(of: "8", with: "")
    let value = value.replacingOccurrences(of: "9", with: "")
    let value = value.replacingOccurrences(of: "0", with: "")
    let value = value.replacingOccurrences(of: "1", with: "")
    let value =

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
    var value = value.replacingOccurrences(of: ".", with: "")
    var value = value.replacingOccurrences(of: ",", with: "")
    var value = value.replacingOccurrences(of: " ", with: "")
    var value = value.replacingOccurrences(of: "-", with: "")
    var value = value.replacingOccurrences(of: "+", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with: "")
    var value = value.replacingOccurrences(of: "2", with: "")
    var value = value.replacingOccurrences(of: "3", with: "")
    var value = value.replacingOccurrences(of: "4", with: "")
    var value = value.replacingOccurrences(of: "5", with: "")
    var value = value.replacingOccurrences(of: "6", with: "")
    var value = value.replacingOccurrences(of: "7", with: "")
    var value = value.replacingOccurrences(of: "8", with: "")
    var value = value.replacingOccurrences(of: "9", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "0", with:

func closestInteger(value: String) -> Int {
  let value = Double(value) ?? 0
  let rounded = value.rounded()
  return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  let value = Double(value) ?? 0
  let rounded = value.rounded()
  return Int(rounded)
}
<|file_separator|>

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // code goes here
    var value = value.replacingOccurrences(of: ".", with: "")
    var value = value.replacingOccurrences(of: ",", with: "")
    var value = value.replacingOccurrences(of: " ", with: "")
    var value = value.replacingOccurrences(of: "-", with: "")
    var value = value.replacingOccurrences(of: "+", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with: "")
    var value = value.replacingOccurrences(of: "2", with: "")
    var value = value.replacingOccurrences(of: "3", with: "")
    var value = value.replacingOccurrences(of: "4", with: "")
    var value = value.replacingOccurrences(of: "5", with: "")
    var value = value.replacingOccurrences(of: "6", with: "")
    var value = value.replacingOccurrences(of: "7", with: "")
    var value = value.replacingOccurrences(of: "8", with: "")
    var value = value.replacingOccurrences(of: "9", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with: "")
    var value = value.replacingOccurrences(of: "2", with: "")
    var value = value.replacingOccurrences(of: "3", with: "")
    var value = value.replacingOccurrences(of: "4", with: "")
    var value = value.replacingOccurrences(of: "5", with: "")
    var value = value.replacingOccurrences(of: "6", with: "")
    var value = value.replacingOccurrences(of: "7", with: "")
    var value = value.replacingOccurrences(of: "8", with: "")
    var value = value.replacingOccurrences(of: "9", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with: "")
    var value = value.replacingOccurrences(of: "2", with: "")
    var value = value.replacingOccurrences(of: "3", with: "")
    var value = value.replacingOccurrences(of: "4", with: "")
    var value = value.replacingOccurrences(of: "5", with: "")
    var value = value.replacingOccurrences(of: "6", with: "")
    var value = value.replacingOccurrences(of: "7", with: "")
    var value = value.replacingOccurrences(of: "8", with: "")
    var value = value.replacingOccurrences(of: "9", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with: "")
    var value = value.replacingOccurrences(of: "2", with: "")
    var value = value.replacingOccurrences(of: "3", with: "")
    var value = value.replacingOccurrences(of: "4", with: "")
    var value = value.replacingOccurrences(of: "5", with: "")
    var value = value.replacingOccurrences(of: "6", with: "")
    var value = value.replacingOccurrences(of: "7", with: "")
    var value = value.replacingOccurrences(of: "8", with: "")
    var value = value.replacingOccurrences(of: "9", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with: "")
    var value = value.replacingOccurrences(of: "2", with: "")
    var value = value.replacingOccurrences(of: "3", with: "")
    var value = value.replacingOccurrences(of: "4", with: "")
    var value = value.replacingOccurrences(of: "5", with: "")
    var value = value.replacingOccurrences(of: "6", with: "")
    var value = value.replacingOccurrences(of: "7", with: "")
    var value = value.replacingOccurrences(of: "8", with: "")
    var value = value.replacingOccurrences(of: "9", with: "")
    var value = value.replacingOccurrences(of: "0", with: "")
    var value = value.replacingOccurrences(of: "1", with:

func closestInteger(value: String) -> Int {
    // your code here
    let value = Double(value) ?? 0
    return Int(value.rounded())
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
    let value = Double(value) ?? 0
    return Int(value.rounded())
}
<|file_separator|>

func closestInteger(value: String) -> Int {
  // your code here
  let value = Double(value) ?? 0
  let rounded = (value + 0.5).rounded()
  return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  // your code here
  let value = Double(value) ?? 0
  let rounded = (value + 0.5).rounded()
  return Int(rounded)
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // your code here
    let value = Double(value) ?? 0
    let rounded = value.rounded()
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
    let value = Double(value) ?? 0
    let rounded = value.rounded()
    return Int(rounded)
}
<|file_separator|>

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  // your code here
  let value = value.replacingOccurrences(of: ".", with: "")
  let value = value.replacingOccurrences(of: ",", with: "")
  let value = value.replacingOccurrences(of: " ", with: "")
  let value = value.replacingOccurrences(of: "-", with: "")
  let value = value.replacingOccurrences(of: "+", with: "")
  let value = value.replacingOccurrences(of: "0", with: "")
  let value = value.replacingOccurrences(of: "1", with: "")
  let value = value.replacingOccurrences(of: "2", with: "")
  let value = value.replacingOccurrences(of: "3", with: "")
  let value = value.replacingOccurrences(of: "4", with: "")
  let value = value.replacingOccurrences(of: "5", with: "")
  let value = value.replacingOccurrences(of: "6", with: "")
  let value = value.replacingOccurrences(of: "7", with: "")
  let value = value.replacingOccurrences(of: "8", with: "")
  let value = value.replacingOccurrences(of: "9", with: "")
  let value = value.replacingOccurrences(of: "0", with: "")
  let value = value.replacingOccurrences(of: "1", with: "")
  let value = value.replacingOccurrences(of: "2", with: "")
  let value = value.replacingOccurrences(of: "3", with: "")
  let value = value.replacingOccurrences(of: "4", with: "")
  let value = value.replacingOccurrences(of: "5", with: "")
  let value = value.replacingOccurrences(of: "6", with: "")
  let value = value.replacingOccurrences(of: "7", with: "")
  let value = value.replacingOccurrences(of: "8", with: "")
  let value = value.replacingOccurrences(of: "9", with: "")
  let value = value.replacingOccurrences(of: "0", with: "")
  let value = value.replacingOccurrences(of: "1", with: "")
  let value = value.replacingOccurrences(of: "2", with: "")
  let value = value.replacingOccurrences(of: "3", with: "")
  let value = value.replacingOccurrences(of: "4", with: "")
  let value = value.replacingOccurrences(of: "5", with: "")
  let value = value.replacingOccurrences(of: "6", with: "")
  let value = value.replacingOccurrences(of: "7", with: "")
  let value = value.replacingOccurrences(of: "8", with: "")
  let value = value.replacingOccurrences(of: "9", with: "")
  let value = value.replacingOccurrences(of: "0", with: "")
  let value = value.replacingOccurrences(of: "1", with: "")
  let value = value.replacingOccurrences(of: "2", with: "")
  let value = value.replacingOccurrences(of: "3", with: "")
  let value = value.replacingOccurrences(of: "4", with: "")
  let value = value.replacingOccurrences(of: "5", with: "")
  let value = value.replacingOccurrences(of: "6", with: "")
  let value = value.replacingOccurrences(of: "7", with: "")
  let value = value.replacingOccurrences(of: "8", with: "")
  let value = value.replacingOccurrences(of: "9", with: "")
  let value = value.replacingOccurrences(of: "0", with: "")
  let value = value.replacingOccurrences(of: "1", with: "")
  let value = value.replacingOccurrences(of: "2", with: "")
  let value = value.replacingOccurrences(of: "3", with: "")
  let value = value.replacingOccurrences(of: "4", with: "")
  let value = value.replacingOccurrences(of: "5", with: "")
  let value = value.replacingOccurrences(of: "6", with: "")
  let value = value.replacingOccurrences(of: "7", with: "")
  let value = value.replacingOccurrences(of: "8", with: "")
  let value = value.replacingOccurrences(of: "9", with: "")
  let value = value.replacingOccurrences(of: "0", with: "")
  let value = value.replacingOccurrences(of: "1", with:

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = value.rounded()
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = value.rounded()
    return Int(rounded)
}
<|file_separator|>

func closestInteger(value: String) -> Int {
  // your code here
  let value = Double(value) ?? 0
  let rounded = (value + 0.5).rounded()
  return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  // your code here
  let value = Double(value) ?? 0
  let rounded = (value + 0.5).rounded()
  return Int(rounded)
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    
    if abs(number - roundedNumber) >= 0.5 {
        return Int(roundedNumber + (number > 0 ? 1 : -1))
    } else {
        return Int(roundedNumber)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    
    if abs(number - roundedNumber) >= 0.5 {
        return Int(roundedNumber + (number > 0 ? 1 : -1))
    } else {
        return Int(roundedNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    if number == roundedNumber {
        return Int(number)
    } else if number > 0 {
        return Int(roundedNumber) + 1
    } else {
        return Int(roundedNumber) - 1
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    if number == roundedNumber {
        return Int(number)
    } else if number > 0 {
        return Int(roundedNumber) + 1
    } else {
        return Int(roundedNumber) - 1
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    let decimalPart = number.truncatingRemainder(dividingBy: 1)
    
    if decimalPart >= 0.5 {
        return Int(roundedNumber + 1)
    } else if decimalPart <= -0.5 {
        return Int(roundedNumber - 1)
    } else {
        return Int(roundedNumber)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    let decimalPart = number.truncatingRemainder(dividingBy: 1)
    
    if decimalPart >= 0.5 {
        return Int(roundedNumber + 1)
    } else if decimalPart <= -0.5 {
        return Int(roundedNumber - 1)
    } else {
        return Int(roundedNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    
    if abs(number - roundedNumber) >= 0.5 {
        return Int(roundedNumber + (number > 0 ? 1 : -1))
    } else {
        return Int(roundedNumber)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    
    if abs(number - roundedNumber) >= 0.5 {
        return Int(roundedNumber + (number > 0 ? 1 : -1))
    } else {
        return Int(roundedNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    let decimalPart = number.truncatingRemainder(dividingBy: 1)
    
    if decimalPart >= 0.5 {
        return Int(roundedNumber + 1)
    } else if decimalPart <= -0.5 {
        return Int(roundedNumber - 1)
    } else {
        return Int(roundedNumber)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    let roundedNumber = round(number)
    let decimalPart = number.truncatingRemainder(dividingBy: 1)
    
    if decimalPart >= 0.5 {
        return Int(roundedNumber + 1)
    } else if decimalPart <= -0.5 {
        return Int(roundedNumber - 1)
    } else {
        return Int(roundedNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    if number == roundedNumber {
        return Int(number)
    } else if number > 0 {
        return Int(roundedNumber) + 1
    } else {
        return Int(roundedNumber) - 1
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    if number == roundedNumber {
        return Int(number)
    } else if number > 0 {
        return Int(roundedNumber) + 1
    } else {
        return Int(roundedNumber) - 1
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    if abs(number - rounded) >= 0.5 {
        return Int(rounded + (number > 0 ? 1 : -1))
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = Int(round(number))
    let distance = abs(closest - number)
    let distanceFromZero = abs(closest)
    if distance < distanceFromZero {
        return closest
    } else {
        return closest * -1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = Int(round(number))
    let distance = abs(closest - number)
    let distanceFromZero = abs(closest)
    if distance < distanceFromZero {
        return closest
    } else {
        return closest * -1
    }
}
```

func closestInteger(value: String) -> Int {
    return Int(value)?? 0
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)?? 0
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    return 0
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return 0
}
```

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```

func closestInteger(value: String) -> Int {
    return 0
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return 0
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    if roundedValue == doubleValue {
        return roundedIntValue
    } else {
        return roundedIntValue + (roundedValue > doubleValue? 1 : -1)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    if roundedValue == doubleValue {
        return roundedIntValue
    } else {
        return roundedIntValue + (roundedValue > doubleValue? 1 : -1)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded()
    let roundedInt = Int(rounded)
    let roundedDouble = Double(roundedInt)
    let diff = abs(number - roundedDouble)
    if diff == 0.5 {
        return roundedInt
    } else if diff < 0.5 {
        return roundedInt
    } else {
        return roundedInt + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded()
    let roundedInt = Int(rounded)
    let roundedDouble = Double(roundedInt)
    let diff = abs(number - roundedDouble)
    if diff == 0.5 {
        return roundedInt
    } else if diff < 0.5 {
        return roundedInt
    } else {
        return roundedInt + 1
    }
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)
    let roundedValue = round(doubleValue!)
    return Int(roundedValue)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)
    let roundedValue = round(doubleValue!)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    if roundedValue - Double(roundedIntValue) < 0.5 {
        return roundedIntValue
    } else {
        return roundedIntValue + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    if roundedValue - Double(roundedIntValue) < 0.5 {
        return roundedIntValue
    } else {
        return roundedIntValue + 1
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = Int(round(number))
    return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = Int(round(number))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded(.awayFromZero)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded(.awayFromZero)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)
    let roundedValue = round(doubleValue!)
    return Int(roundedValue)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)
    let roundedValue = round(doubleValue!)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    if abs(doubleValue - Double(roundedIntValue)) < abs(doubleValue - Double(roundedIntValue + 1)) {
        return roundedIntValue
    } else {
        return roundedIntValue + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    if abs(doubleValue - Double(roundedIntValue)) < abs(doubleValue - Double(roundedIntValue + 1)) {
        return roundedIntValue
    } else {
        return roundedIntValue + 1
    }
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
  // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  // your code here
}
```

func closestInteger(value: String) -> Int {
    // Your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Your code here
}
```

func closestInteger(value: String) -> Int {
    let num = Double(value)!
    let rounded = round(num)
    let floored = floor(num)
    let ceiled = ceil(num)
    if rounded == floored {
        return Int(floored)
    } else if rounded == ceiled {
        return Int(ceiled)
    } else if rounded > 0 {
        return Int(ceiled)
    } else {
        return Int(floored)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let num = Double(value)!
    let rounded = round(num)
    let floored = floor(num)
    let ceiled = ceil(num)
    if rounded == floored {
        return Int(floored)
    } else if rounded == ceiled {
        return Int(ceiled)
    } else if rounded > 0 {
        return Int(ceiled)
    } else {
        return Int(floored)
    }
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    let num = Double(value)!
    let rounded = round(num)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let num = Double(value)!
    let rounded = round(num)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let floored = floor(number)
    let ceiled = ceil(number)
    let roundedAwayFromZero = (rounded > 0)? ceiled : floored
    return Int(roundedAwayFromZero)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let floored = floor(number)
    let ceiled = ceil(number)
    let roundedAwayFromZero = (rounded > 0)? ceiled : floored
    return Int(roundedAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return rounded.toInt()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return rounded.toInt()
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return rounded == number? rounded < 0? rounded - 1 : rounded + 1 : rounded
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return rounded == number? rounded < 0? rounded - 1 : rounded + 1 : rounded
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return rounded.toInt()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return rounded.toInt()
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)!
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)!
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = round(number)
    return Int(closest)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = round(number)
    return Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = round(number)
    return Int(closest)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = round(number)
    return Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let closest = round(doubleValue)
    return Int(closest)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let closest = round(doubleValue)
    return Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0.0
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0.0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = round(number)
    return Int(closest)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let closest = round(number)
    return Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0.0
    let closest = round(number)
    return Int(closest)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0.0
    let closest = round(number)
    return Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let closest = round(doubleValue)
    return Int(closest)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0.0
    let closest = round(doubleValue)
    return Int(closest)
}
```

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    
    guard let doubleValue(

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    
    
    let num = Double(Double(Double(value:

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    
    let doubleValue = Double(Double(value =

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    
    

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    let number

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    
    

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
}

/*
 Create a function that takes a value (string) representing a number
 and returns the closest integer to it. If the number is equidistant
 from two integers, round it away from zero.
 Examples
 Note:
 Rounding away from zero means that if the given number is equidistant
 from two integers, the one you should return is the one that is the
 farthest from zero. For example closest_integer("14.5") should
 return 15 and closest_integer("-14.5") should return -15.
 closestInteger(value: "10") == 10
 closestInteger(value: "15.3") == 15
 */
func closestInteger(value: String) -> Int {
    
    
    
    

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {

1.

Here is the one of the one that is

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {




Here is the one of the one of the one that

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {


Here is the one that is the one that is the one

func closestInteger(value: String) -> Int {


Here is the one of the one that is the one that is always positive, which is greater in absolute value is even number if the given number is even.
 greater when the absolute is even.
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {


Here is the one of the one that is the one that is always positive, which is greater in absolute value is even number if the given number is even.
 greater when the absolute is even.
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {



Here is the one of the one of the integer that is the integer that is the one that is closer to zero's farther from zero if it is even.


















that is even


that is even

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {



Here is the one of the one of the one that is

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {


Here is the one that is the one that is the one that is closer to zero or the one that is farthest to zero if it is positive.






that is even number is even number.




that is even
that is even











that



that
```

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {


Here is positive, if the one that is positive, and negative if the number is positive.
 greater than the one.

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {






1. If the one of the one of

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {


Here is positive, if the one that is positive, negative if the given number is positive.
 greater than the given number is positive.
    
    
    return Int(Int(Int(Int(Int(

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) + 1 : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1.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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) + 1 : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) + 1 : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1.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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) + 1 : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) + 1 : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1.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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) + 1 : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.truncatingRemainder(dividingBy: 1.0) == 0.5 && floatValue > 0 || floatValue < 0 ? Int(floatValue.rounding(to: .down)) : Int(floatValue.rounding(to: .up))
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.truncatingRemainder(dividingBy: 1.0) == 0.5 && floatValue > 0 || floatValue < 0 ? Int(floatValue.rounding(to: .down)) : Int(floatValue.rounding(to: .up))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 1)) : Int(floatValue.roundingMode == .up ? floatValue.truncatingRemainder(dividingBy: 1) + 1 : floatValue.truncatingRemainder(dividingBy: 1) - 1)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 1)) : Int(floatValue.roundingMode == .up ? floatValue.truncatingRemainder(dividingBy: 1) + 1 : floatValue.truncatingRemainder(dividingBy: 1) - 1)
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.truncatingRemainder(dividingBy: 1) == 0.5 ? Int(floatValue.rounded()) : Int(floatValue.rounded()) * (floatValue.rounded() < floatValue ? 1 : -1)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.truncatingRemainder(dividingBy: 1) == 0.5 ? Int(floatValue.rounded()) : Int(floatValue.rounded()) * (floatValue.rounded() < floatValue ? 1 : -1)
}
```

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) :
    floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .down ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toNegativeInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .nan ? 0 :
    floatValue.roundingMode == .infinity ? 0 :
    floatValue.roundingMode == .negativeOrZero ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .positiveOrZero ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .zero ? 0 :
    floatValue.roundingMode == .negativeOrInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .positiveOrInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .negativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .positiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .infinityOrNegative ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .infinityOrPositive ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .negativeOrInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .positiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .negativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .negativeOrZeroOrInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .positiveOrZeroOrInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .negativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .positiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .negativeOrZeroOrNegativeInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .positiveOrZeroOrPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .negativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .positiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .negativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .negativeOrZeroOrNegativeInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .positiveOrZeroOrPositiveInfinity ? Int(floatValue.truncatingRemain

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 1)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1))
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 1)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1)) + 1 : Int(floatValue.truncatingRemainder(dividingBy: 1))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 1)) : Int(floatValue.roundingMode == .halfToEven ? floatValue.truncatingRemainder(dividingBy: 1) : floatValue.roundingMode == .halfToZero ? floatValue.truncatingRemainder(dividingBy: 1) : floatValue.roundingMode == .up ? floatValue.truncatingRemainder(dividingBy: 1) + 1 : floatValue.truncatingRemainder(dividingBy: 1) - 1)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 1)) : Int(floatValue.roundingMode == .halfToEven ? floatValue.truncatingRemainder(dividingBy: 1) : floatValue.roundingMode == .halfToZero ? floatValue.truncatingRemainder(dividingBy: 1) : floatValue.roundingMode == .up ? floatValue.truncatingRemainder(dividingBy: 1) + 1 : floatValue.truncatingRemainder(dividingBy: 1) - 1)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number! * 10) / 10
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number! * 10) / 10
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorValue = floor(number!)
    let ceilValue = ceil(number!)
    
    if (number! - floorValue) < (ceilValue - number!) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorValue = floor(number!)
    let ceilValue = ceil(number!)
    
    if (number! - floorValue) < (ceilValue - number!) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorValue = floor(number!)
    let ceilValue = ceil(number!)
    
    if (number! - floorValue) < (ceilValue - number!) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorValue = floor(number!)
    let ceilValue = ceil(number!)
    
    if (number! - floorValue) < (ceilValue - number!) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number! * 10) / 10
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number! * 10) / 10
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number!)
    let roundedUp = ceil(number!)
    let roundedDown = floor(number!)

    if (number! - roundedUp) < (rounded - number!) {
        return Int(roundedUp)
    } else if (number! - roundedDown) < (rounded - number!) {
        return Int(roundedDown)
    } else {
        return Int(rounded)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number!)
    let roundedUp = ceil(number!)
    let roundedDown = floor(number!)

    if (number! - roundedUp) < (rounded - number!) {
        return Int(roundedUp)
    } else if (number! - roundedDown) < (rounded - number!) {
        return Int(roundedDown)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorValue = floor(number!)
    let ceilValue = ceil(number!)
    
    if (number! - floorValue) < (ceilValue - number!) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorValue = floor(number!)
    let ceilValue = ceil(number!)
    
    if (number! - floorValue) < (ceilValue - number!) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(number.rounded())
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(number.rounded())
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(number.rounded())
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(number.rounded())
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(number.rounded())
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(number.rounded())
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}

<｜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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    return Int(rounded)
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number + (number.truncatingRemainder(dividingBy: 1) >= 0.5 ? 1 : 0))
        } else {
            return Int(number - (number.truncatingRemainder(dividingBy: 1) >= 0.5 ? 1 : 0))
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number + (number.truncatingRemainder(dividingBy: 1) >= 0.5 ? 1 : 0))
        } else {
            return Int(number - (number.truncatingRemainder(dividingBy: 1) >= 0.5 ? 1 : 0))
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(-(-number).rounded(.awayFromZero))
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(-(-number).rounded(.awayFromZero))
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(-(-number).rounded(.awayFromZero))
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(-(-number).rounded(.awayFromZero))
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number + 0.5)
        } else {
            return Int(number - 0.5)
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number + 0.5)
        } else {
            return Int(number - 0.5)
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        let roundedNumber = number >= 0 ? floor(number + 0.5) : ceil(number - 0.5)
        return Int(roundedNumber)
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        let roundedNumber = number >= 0 ? floor(number + 0.5) : ceil(number - 0.5)
        return Int(roundedNumber)
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            let roundedNumber = number.rounded(.awayFromZero)
            return Int(roundedNumber)
        } else {
            let roundedNumber = -number.rounded(.awayFromZero)
            return Int(roundedNumber)
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            let roundedNumber = number.rounded(.awayFromZero)
            return Int(roundedNumber)
        } else {
            let roundedNumber = -number.rounded(.awayFromZero)
            return Int(roundedNumber)
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(number.rounded(.towardZero))
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(number.rounded(.towardZero))
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number + 0.5)
        } else {
            return Int(number - 0.5)
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number + 0.5)
        } else {
            return Int(number - 0.5)
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(-(-number).rounded(.awayFromZero))
        }
    } else {
        return 0
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        if number >= 0 {
            return Int(number.rounded(.awayFromZero))
        } else {
            return Int(-(-number).rounded(.awayFromZero))
        }
    } else {
        return 0
    }
}
```

import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        let roundedNumber = number.rounded(.awayFromZero)
        return Int(roundedNumber)
    }
    return 0
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
import Foundation

func closestInteger(value: String) -> Int {
    if let number = Double(value) {
        let roundedNumber = number.rounded(.awayFromZero)
        return Int(roundedNumber)
    }
    return 0
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }
    
    let floorValue = floor(doubleValue)
    let ceilValue = ceil(doubleValue)
    
    // Check if the number is equidistant from two integers
    if doubleValue - floorValue == ceilValue - doubleValue {
        // If so, round away from zero
        return doubleValue > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return intValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }
    
    let floorValue = floor(doubleValue)
    let ceilValue = ceil(doubleValue)
    
    // Check if the number is equidistant from two integers
    if doubleValue - floorValue == ceilValue - doubleValue {
        // If so, round away from zero
        return doubleValue > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return intValue
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error
    }
    
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    // Check if the number is equidistant from two integers
    if number - floorValue == ceilValue - number {
        // If so, round away from zero
        return number > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return Int(number.rounded())
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error
    }
    
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    // Check if the number is equidistant from two integers
    if number - floorValue == ceilValue - number {
        // If so, round away from zero
        return number > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return Int(number.rounded())
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    // Check if the number is equidistant from two integers
    if number - floorValue == ceilValue - number {
        // If so, round away from zero
        return number > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return Int(number.rounded())
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    // Check if the number is equidistant from two integers
    if number - floorValue == ceilValue - number {
        // If so, round away from zero
        return number > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return Int(number.rounded())
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input. Please provide a valid number.")
    }
    
    let roundedNumber = round(number)
    
    // Check if the number is equidistant from two integers
    if number - roundedNumber == 0.5 {
        return Int(number > 0 ? ceil(number) : floor(number))
    } else {
        return Int(roundedNumber)
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        fatalError("Invalid input. Please provide a valid number.")
    }
    
    let roundedNumber = round(number)
    
    // Check if the number is equidistant from two integers
    if number - roundedNumber == 0.5 {
        return Int(number > 0 ? ceil(number) : floor(number))
    } else {
        return Int(roundedNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    return Int(doubleValue.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    return Int(doubleValue.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    
    let floorValue = floor(doubleValue)
    let ceilValue = ceil(doubleValue)
    
    // Check if the number is equidistant from two integers
    if doubleValue - floorValue == ceilValue - doubleValue {
        // If so, round away from zero
        return doubleValue > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return intValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    
    let floorValue = floor(doubleValue)
    let ceilValue = ceil(doubleValue)
    
    // Check if the number is equidistant from two integers
    if doubleValue - floorValue == ceilValue - doubleValue {
        // If so, round away from zero
        return doubleValue > 0 ? Int(ceilValue) : Int(floorValue)
    } else {
        // If not, return the closest integer
        return intValue
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error if you want
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error if you want
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    return Int(doubleValue.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0 // or throw an error, depending on your requirements
    }
    return Int(doubleValue.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0
    }
    let roundedNumber = Int(number.rounded(.awayFromZero))
    return roundedNumber
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }
    
    let floorValue = floor(doubleValue)
    let ceilValue = ceil(doubleValue)
    
    if doubleValue - floorValue < ceilValue - doubleValue {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }
    
    let floorValue = floor(doubleValue)
    let ceilValue = ceil(doubleValue)
    
    if doubleValue - floorValue < ceilValue - doubleValue {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error if you want
    }
    return Int(number.rounded(.awayFromZero))
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else {
        return 0 // or throw an error if you want
    }
    return Int(number.rounded(.awayFromZero))
}
```

func closestInteger(value: String) -> Int {
    let value = Double(value)
    let value = value!
    let value = value.rounded()
    let value = Int(value)
    return value
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value)
    let value = value!
    let value = value.rounded()
    let value = Int(value)
    return value
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    if abs(roundedUp - number) < abs(roundedDown - number) {
        return Int(roundedUp)
    } else {
        return Int(roundedDown)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    if abs(roundedUp - number) < abs(roundedDown - number) {
        return Int(roundedUp)
    } else {
        return Int(roundedDown)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(number - roundedUp) < abs(number - roundedDown) {
        return Int(roundedUp)
    } else {
        return Int(roundedDown)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(number - roundedUp) < abs(number - roundedDown) {
        return Int(roundedUp)
    } else {
        return Int(roundedDown)
    }
}
```

func closestInteger(value: String) -> Int {
    let value = Double(value)
    let roundedValue = round(value!)
    let roundedValueAwayFromZero = round(abs(value!))
    if abs(value!) == roundedValueAwayFromZero {
        return Int(roundedValueAwayFromZero)
    } else {
        return Int(roundedValue)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value)
    let roundedValue = round(value!)
    let roundedValueAwayFromZero = round(abs(value!))
    if abs(value!) == roundedValueAwayFromZero {
        return Int(roundedValueAwayFromZero)
    } else {
        return Int(roundedValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) > abs(roundedDown - number) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) > abs(roundedDown - number) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    if abs(number - roundedUp) > abs(number - roundedDown) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    if abs(number - roundedUp) > abs(number - roundedDown) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) > abs(roundedDown - number) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) > abs(roundedDown - number) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}
```

func closestInteger(value: String) -> Int {
    let value = Double(value)!
    let rounded = round(value)
    let roundedUp = ceil(value)
    let roundedDown = floor(value)
    if abs(roundedUp - value) > abs(roundedDown - value) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value)!
    let rounded = round(value)
    let roundedUp = ceil(value)
    let roundedDown = floor(value)
    if abs(roundedUp - value) > abs(roundedDown - value) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) == abs(roundedDown - number) {
        if roundedUp > roundedDown {
            return Int(roundedUp)
        } else {
            return Int(roundedDown)
        }
    } else if abs(roundedUp - number) > abs(roundedDown - number) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) == abs(roundedDown - number) {
        if roundedUp > roundedDown {
            return Int(roundedUp)
        } else {
            return Int(roundedDown)
        }
    } else if abs(roundedUp - number) > abs(roundedDown - number) {
        return Int(roundedDown)
    } else {
        return Int(roundedUp)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) == abs(roundedDown - number) {
        return Int(roundedUp)
    }
    
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedUp = ceil(number)
    let roundedDown = floor(number)
    
    if abs(roundedUp - number) == abs(roundedDown - number) {
        return Int(roundedUp)
    }
    
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}
```

func closestInteger(value: String) -> Int {
    // TODO: Implement closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: Implement closestInteger
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement closest integer
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement closest integer
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement this function
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement this function
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement this function
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement this function
}
```

func closestInteger(value: String) -> Int {
    // TODO: Implement this function
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: Implement this function
}
```

func closestInteger(value: String) -> Int {
    // TODO: Implement closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: Implement closestInteger
}
```

func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // TODO: implement closestInteger
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        fatalError("Invalid number value")
    }
    
    let roundedValue = round(doubleValue)
    
    let intValue = Int(roundedValue)
    
    let nextIntValue = Int(ceil(doubleValue))
    
    let diffToInt = abs(intValue - roundedValue)
    let diffToNextInt = abs(nextIntValue - roundedValue)
    
    if diffToInt < diffToNextInt {
        return intValue
    } else {
        return nextIntValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        fatalError("Invalid number value")
    }
    
    let roundedValue = round(doubleValue)
    
    let intValue = Int(roundedValue)
    
    let nextIntValue = Int(ceil(doubleValue))
    
    let diffToInt = abs(intValue - roundedValue)
    let diffToNextInt = abs(nextIntValue - roundedValue)
    
    if diffToInt < diffToNextInt {
        return intValue
    } else {
        return nextIntValue
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let decimalPart = doubleValue - roundedValue
    
    if decimalPart > 0.5 {
        if doubleValue > 0 {
            return roundedValue + 1
        } else {
            return roundedValue - 1
        }
    } else if decimalPart < -0.5 {
        if doubleValue > 0 {
            return roundedValue - 1
        } else {
            return roundedValue + 1
        }
    } else {
        return roundedValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let decimalPart = doubleValue - roundedValue
    
    if decimalPart > 0.5 {
        if doubleValue > 0 {
            return roundedValue + 1
        } else {
            return roundedValue - 1
        }
    } else if decimalPart < -0.5 {
        if doubleValue > 0 {
            return roundedValue - 1
        } else {
            return roundedValue + 1
        }
    } else {
        return roundedValue
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let decimalPart = doubleValue - roundedValue
    
    if decimalPart > 0.5 {
        if doubleValue > 0 {
            return roundedValue + 1
        } else {
            return roundedValue - 1
        }
    } else if decimalPart < -0.5 {
        if doubleValue > 0 {
            return roundedValue - 1
        } else {
            return roundedValue + 1
        }
    } else {
        return roundedValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let decimalPart = doubleValue - roundedValue
    
    if decimalPart > 0.5 {
        if doubleValue > 0 {
            return roundedValue + 1
        } else {
            return roundedValue - 1
        }
    } else if decimalPart < -0.5 {
        if doubleValue > 0 {
            return roundedValue - 1
        } else {
            return roundedValue + 1
        }
    } else {
        return roundedValue
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let nearestInteger = int(roundedValue)
    
    let absoluteDifferenceToNearestInteger = abs(roundedValue - doubleValue)
    let absoluteDifferenceToRoundedValue = abs(nearestInteger - doubleValue)
    
    if absoluteDifferenceToNearestInteger <= absoluteDifferenceToRoundedValue {
        return nearestInteger
    } else {
        return roundedValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let nearestInteger = int(roundedValue)
    
    let absoluteDifferenceToNearestInteger = abs(roundedValue - doubleValue)
    let absoluteDifferenceToRoundedValue = abs(nearestInteger - doubleValue)
    
    if absoluteDifferenceToNearestInteger <= absoluteDifferenceToRoundedValue {
        return nearestInteger
    } else {
        return roundedValue
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let decimalPart = doubleValue - roundedValue
    
    if decimalPart > 0.5 {
        if doubleValue > 0 {
            return roundedValue + 1
        } else {
            return roundedValue - 1
        }
    } else if decimalPart < -0.5 {
        if doubleValue > 0 {
            return roundedValue - 1
        } else {
            return roundedValue + 1
        }
    } else {
        return roundedValue
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let decimalPart = doubleValue - roundedValue
    
    if decimalPart > 0.5 {
        if doubleValue > 0 {
            return roundedValue + 1
        } else {
            return roundedValue - 1
        }
    } else if decimalPart < -0.5 {
        if doubleValue > 0 {
            return roundedValue - 1
        } else {
            return roundedValue + 1
        }
    } else {
        return roundedValue
    }
}
```

func closestInteger(value: String) -> Int {
    if let doubleValue = Double(value) {
        let roundedValue = round(doubleValue)
        let intValue = Int(roundedValue)
        
        let diffToIntLess = abs(doubleValue - Double(intValue - 1))
        let diffToIntMore = abs(doubleValue - Double(intValue + 1))
        
        if diffToIntLess < diffToIntMore {
            return intValue - 1
        } else {
            return intValue
        }
    } else {
        fatalError("Invalid input. Please provide a valid number.")
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    if let doubleValue = Double(value) {
        let roundedValue = round(doubleValue)
        let intValue = Int(roundedValue)
        
        let diffToIntLess = abs(doubleValue - Double(intValue - 1))
        let diffToIntMore = abs(doubleValue - Double(intValue + 1))
        
        if diffToIntLess < diffToIntMore {
            return intValue - 1
        } else {
            return intValue
        }
    } else {
        fatalError("Invalid input. Please provide a valid number.")
    }
}
```

func closestInteger(value: String) -> Int {
    if let doubleValue = Double(value) {
        let roundedValue = round(doubleValue)
        let intValue = Int(roundedValue)
        
        let diffToIntLess = abs(doubleValue - Double(intValue - 1))
        let diffToIntMore = abs(doubleValue - Double(intValue + 1))
        
        if diffToIntLess <= diffToIntMore {
            return intValue - 1
        } else {
            return intValue + 1
        }
    } else {
        // Return 0 if the conversion to Double fails
        return 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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    if let doubleValue = Double(value) {
        let roundedValue = round(doubleValue)
        let intValue = Int(roundedValue)
        
        let diffToIntLess = abs(doubleValue - Double(intValue - 1))
        let diffToIntMore = abs(doubleValue - Double(intValue + 1))
        
        if diffToIntLess <= diffToIntMore {
            return intValue - 1
        } else {
            return intValue + 1
        }
    } else {
        // Return 0 if the conversion to Double fails
        return 0
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let absoluteDifferenceToNegative = abs(roundedValue - doubleValue)
    let absoluteDifferenceToPositive = abs(roundedValue + 1 - doubleValue)
    
    if absoluteDifferenceToNegative < absoluteDifferenceToPositive {
        return Int(roundedValue)
    } else {
        return Int(roundedValue + 1)
    }
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        print("Invalid input. Please enter a valid number.")
        return 0
    }
    
    let roundedValue = round(doubleValue)
    let absoluteDifferenceToNegative = abs(roundedValue - doubleValue)
    let absoluteDifferenceToPositive = abs(roundedValue + 1 - doubleValue)
    
    if absoluteDifferenceToNegative < absoluteDifferenceToPositive {
        return Int(roundedValue)
    } else {
        return Int(roundedValue + 1)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input. Please provide a valid number.")
    }
    
    let roundedValue = round(doubleValue)
    let closestInt = doubleValue < 0? Int(roundedValue - 0.5) : Int(roundedValue + 0.5)
    
    return closestInt
}

<|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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input. Please provide a valid number.")
    }
    
    let roundedValue = round(doubleValue)
    let closestInt = doubleValue < 0? Int(roundedValue - 0.5) : Int(roundedValue + 0.5)
    
    return closestInt
}
```

func closestInteger(value: String) -> Int {
    if let doubleValue = Double(value) {
        let roundedValue = round(doubleValue)
        let intValue = Int(roundedValue)
        
        let diffToIntLess = abs(doubleValue - Double(intValue - 1))
        let diffToIntMore = abs(doubleValue - Double(intValue + 1))
        
        if diffToIntLess <= diffToIntMore {
            return intValue - 1
        } else {
            return intValue
        }
    } else {
        // Return 0 if the conversion to Double fails
        return 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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<|im_end|>
<|im_start|>assistant
```swift
func closestInteger(value: String) -> Int {
    if let doubleValue = Double(value) {
        let roundedValue = round(doubleValue)
        let intValue = Int(roundedValue)
        
        let diffToIntLess = abs(doubleValue - Double(intValue - 1))
        let diffToIntMore = abs(doubleValue - Double(intValue + 1))
        
        if diffToIntLess <= diffToIntMore {
            return intValue - 1
        } else {
            return intValue
        }
    } else {
        // Return 0 if the conversion to Double fails
        return 0
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```
### Challenge

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}
```
### Ex

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = Int(number + 0.5)
    return rounded
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = Int(number + 0.5)
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = Int(round(number))
    if rounded == number {
        return rounded
    } else {
        if rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = Int(round(number))
    if rounded == number {
        return rounded
    } else {
        if rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}
```
### Question

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}
```
### Problem

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = Int(number + 0.5)
    return rounded
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = Int(number + 0.5)
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}
```
### Question

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    return Int(round(number))
}
```

func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(round(num!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(round(num!))
}
```
### Test

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```

func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(num!.rounded())
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(num!.rounded())
}
```
### Test

func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(round(num!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(round(num!))
}
```
### Test

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```
### Test

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```
### Test

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number!)
    if rounded == number! {
        return Int(rounded)
    } else {
        return Int(rounded) + 1
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number!)
    if rounded == number! {
        return Int(rounded)
    } else {
        return Int(rounded) + 1
    }
}
```
### Test

func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(round(num!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let num = Double(value)
    return Int(round(num!))
}
```
### Test

func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    return Int(round(Double(value)!))
}
```
### Test

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    return rounded == closest ? Int(rounded) : Int(rounded + number.sign.rawValue)
}

extension Double {
    var sign: FloatingPointSign {
        return self >= 0 ? .plus : .minus
    }
}

enum FloatingPointSign {
    case plus, minus
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    return rounded == closest ? Int(rounded) : Int(rounded + number.sign.rawValue)
}

extension Double {
    var sign: FloatingPointSign {
        return self >= 0 ? .plus : .minus
    }
}

enum FloatingPointSign {
    case plus, minus
}
```

func closestInteger(value: String) -> Int {
    let roundedValue = Double(value) ?? 0.0
    let roundedValueInt = Int(roundedValue)
    let decimalPart = roundedValue - Double(roundedValueInt)
    if decimalPart == 0.5 {
        return roundedValueInt + 1
    } else if decimalPart == -0.5 {
        return roundedValueInt - 1
    } else {
        return roundedValueInt
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let roundedValue = Double(value) ?? 0.0
    let roundedValueInt = Int(roundedValue)
    let decimalPart = roundedValue - Double(roundedValueInt)
    if decimalPart == 0.5 {
        return roundedValueInt + 1
    } else if decimalPart == -0.5 {
        return roundedValueInt - 1
    } else {
        return roundedValueInt
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let closest = number < 0 ? ceil(number) : floor(number)
    return abs(rounded - number) == abs(closest - number)
        ? rounded > 0 ? Int(rounded - 1) : Int(rounded + 1)
        : Int(rounded)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let closest = number < 0 ? ceil(number) : floor(number)
    return abs(rounded - number) == abs(closest - number)
        ? rounded > 0 ? Int(rounded - 1) : Int(rounded + 1)
        : Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value) ?? 0
    let intValue = Int(doubleValue)
    let fraction = doubleValue - Double(intValue)
    if fraction < 0.5 {
        return intValue
    } else if fraction > 0.5 {
        return intValue + 1
    } else {
        if intValue > 0 {
            return intValue + 1
        } else {
            return intValue - 1
        }
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value) ?? 0
    let intValue = Int(doubleValue)
    let fraction = doubleValue - Double(intValue)
    if fraction < 0.5 {
        return intValue
    } else if fraction > 0.5 {
        return intValue + 1
    } else {
        if intValue > 0 {
            return intValue + 1
        } else {
            return intValue - 1
        }
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let closest = number < 0 ? ceil(number - 0.5) : floor(number + 0.5)
    return abs(rounded - number) == abs(closest - number)
        ? Int(rounded)
        : Int(closest)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let closest = number < 0 ? ceil(number - 0.5) : floor(number + 0.5)
    return abs(rounded - number) == abs(closest - number)
        ? Int(rounded)
        : Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    return rounded == closest ? Int(rounded) : Int(rounded + number.sign.rawValue)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    return rounded == closest ? Int(rounded) : Int(rounded + number.sign.rawValue)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    let difference1 = abs(rounded - number)
    let difference2 = abs(closest - number)
    return difference1 < difference2 ? Int(rounded) : Int(closest)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    let difference1 = abs(rounded - number)
    let difference2 = abs(closest - number)
    return difference1 < difference2 ? Int(rounded) : Int(closest)
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value) ?? 0
    let intValue = Int(doubleValue)
    let fraction = doubleValue - Double(intValue)
    if fraction < 0.5 {
        return intValue
    } else if fraction > 0.5 {
        return intValue + 1
    } else {
        return doubleValue > 0 ? intValue + 1 : intValue - 1
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value) ?? 0
    let intValue = Int(doubleValue)
    let fraction = doubleValue - Double(intValue)
    if fraction < 0.5 {
        return intValue
    } else if fraction > 0.5 {
        return intValue + 1
    } else {
        return doubleValue > 0 ? intValue + 1 : intValue - 1
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    return rounded == closest ? Int(rounded) : Int(rounded + number.sign.rawValue)
}

enum Sign: Double {
    case plus = 1.0
    case minus = -1.0

    init(_ value: Double) {
        self = value >= 0 ? .plus : .minus
    }
}

extension Double {
    var sign: Sign {
        return Sign(self)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    let closest = number.sign == .minus ? ceil(number) : floor(number)
    return rounded == closest ? Int(rounded) : Int(rounded + number.sign.rawValue)
}

enum Sign: Double {
    case plus = 1.0
    case minus = -1.0

    init(_ value: Double) {
        self = value >= 0 ? .plus : .minus
    }
}

extension Double {
    var sign: Sign {
        return Sign(self)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    let isLower = roundedNumber < number
    let isUpper = roundedNumber > number
    let isEquidistant = roundedNumber - number == 0.5
    if isEquidistant && isLower {
        return Int(roundedNumber - 1)
    } else if isEquidistant && isUpper {
        return Int(roundedNumber + 1)
    } else {
        return Int(roundedNumber)
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    let isLower = roundedNumber < number
    let isUpper = roundedNumber > number
    let isEquidistant = roundedNumber - number == 0.5
    if isEquidistant && isLower {
        return Int(roundedNumber - 1)
    } else if isEquidistant && isUpper {
        return Int(roundedNumber + 1)
    } else {
        return Int(roundedNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    // Convert the string to a Double and then to an Int
    // If the conversion results in an error, return 0
    guard let doubleValue = Double(value), let intValue = Int(doubleValue) else {
        return 0
    }
    
    // Check if the number is equidistant from two integers
    if doubleValue - Double(intValue) == 0.5 {
        // If equidistant, round away from zero
        return intValue + (intValue > 0 ? 1 : -1)
    } else {
        // If not equidistant, return the integer value
        return intValue
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a Double and then to an Int
    // If the conversion results in an error, return 0
    guard let doubleValue = Double(value), let intValue = Int(doubleValue) else {
        return 0
    }
    
    // Check if the number is equidistant from two integers
    if doubleValue - Double(intValue) == 0.5 {
        // If equidistant, round away from zero
        return intValue + (intValue > 0 ? 1 : -1)
    } else {
        // If not equidistant, return the integer value
        return intValue
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
```

This function uses the `Double` and `Int` types to handle floating-point numbers and integers respectively. It then checks if the number is equidistant from two integers by comparing the difference between the number and the integer to `0.5`. If it is, it rounds away from zero using the `intValue > 0 ? 1 : -1` expression. If not, it returns the integer value.

func closestInteger(value: String) -> Int {
    // Convert the string to a Double and then to an Int
    // If the string is not a valid number, return 0
    if let doubleValue = Double(value), let intValue = Int(doubleValue) {
        return intValue
    } else {
        return 0
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a Double and then to an Int
    // If the string is not a valid number, return 0
    if let doubleValue = Double(value), let intValue = Int(doubleValue) {
        return intValue
    } else {
        return 0
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
print(closestInteger(value: "14.5"))   // Output: 15
```

This function uses the `Double` and `Int` types to handle floating-point numbers and integers respectively. It checks if the string can be converted to a Double and then to an Int. If it is not possible, it returns 0.

func closestInteger(value: String) -> Int {
    // Convert the string to a double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Get the floor and ceiling values
    let floorValue = Int(floor(doubleValue))
    let ceilValue = Int(ceil(doubleValue))
    
    // Determine which value is closer to the original value
    if doubleValue - floor(doubleValue) < ceil(doubleValue) - doubleValue {
        return floorValue
    } else if doubleValue - floor(doubleValue) > ceil(doubleValue) - doubleValue {
        return ceilValue
    } else {
        // If equidistant, round away from zero
        return doubleValue > 0 ? ceilValue : floorValue
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Get the floor and ceiling values
    let floorValue = Int(floor(doubleValue))
    let ceilValue = Int(ceil(doubleValue))
    
    // Determine which value is closer to the original value
    if doubleValue - floor(doubleValue) < ceil(doubleValue) - doubleValue {
        return floorValue
    } else if doubleValue - floor(doubleValue) > ceil(doubleValue) - doubleValue {
        return ceilValue
    } else {
        // If equidistant, round away from zero
        return doubleValue > 0 ? ceilValue : floorValue
    }
}

// Example usage:
print(closestInteger(value: "10"))       // Output: 10
print(closestInteger(value: "15.3"))    // Output: 15
print(closestInteger(value: "-14.5"))   // Output: -15
```

func closestInteger(value: String) -> Int {
    // Convert the string to a Double and then to an Int
    // If the conversion fails, return nil
    if let doubleValue = Double(value), let intValue = Int(doubleValue) {
        // If the number is equidistant from two integers, round away from zero
        if doubleValue - Double(intValue) == 0.5 {
            return intValue + (intValue >= 0 ? 1 : -1)
        } else {
            return intValue
        }
    } else {
        return nil
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a Double and then to an Int
    // If the conversion fails, return nil
    if let doubleValue = Double(value), let intValue = Int(doubleValue) {
        // If the number is equidistant from two integers, round away from zero
        if doubleValue - Double(intValue) == 0.5 {
            return intValue + (intValue >= 0 ? 1 : -1)
        } else {
            return intValue
        }
    } else {
        return nil
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
print(closestInteger(value: "14.5"))   // Output: 15
```

This function uses the `Double` and `Int` types to handle floating-point numbers and integers respectively. It then checks if the number is equidistant from two integers by comparing the difference between the number and the integer to `0.5`. If it is, it rounds away from zero using the `Int` type's `init(truncating:)` method.

func closestInteger(value: String) -> Int {
    // Convert the string to a Double
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Check if the number is equidistant from two integers
    if number - floor(number) == ceil(number) - number {
        // If equidistant, round away from zero
        return number > 0 ? Int(ceil(number)) : Int(floor(number))
    } else {
        // If not equidistant, round to the nearest integer
        return Int(round(number))
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a Double
    guard let number = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Check if the number is equidistant from two integers
    if number - floor(number) == ceil(number) - number {
        // If equidistant, round away from zero
        return number > 0 ? Int(ceil(number)) : Int(floor(number))
    } else {
        // If not equidistant, round to the nearest integer
        return Int(round(number))
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
```

func closestInteger(value: String) -> Int {
    // Convert the string to a double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Get the integer part of the number
    let integerPart = Int(doubleValue)
    
    // Get the decimal part of the number
    let decimalPart = doubleValue - Double(integerPart)
    
    // Check if the number is equidistant from two integers
    if decimalPart == 0.5 {
        // If equidistant, round away from zero
        return integerPart + (doubleValue > 0 ? 1 : -1)
    } else {
        // If not equidistant, round to the nearest integer
        return Int(doubleValue.rounded())
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Get the integer part of the number
    let integerPart = Int(doubleValue)
    
    // Get the decimal part of the number
    let decimalPart = doubleValue - Double(integerPart)
    
    // Check if the number is equidistant from two integers
    if decimalPart == 0.5 {
        // If equidistant, round away from zero
        return integerPart + (doubleValue > 0 ? 1 : -1)
    } else {
        // If not equidistant, round to the nearest integer
        return Int(doubleValue.rounded())
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
```

func closestInteger(value: String) -> Int {
    // Convert the string to a Double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Check if the number is equidistant from two integers
    if doubleValue - Double(Int(doubleValue)) == 0.5 {
        // If equidistant, round away from zero
        return Int(doubleValue > 0 ? ceil(doubleValue) : floor(doubleValue))
    } else {
        // If not equidistant, round to the nearest integer
        return Int(round(doubleValue))
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a Double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Check if the number is equidistant from two integers
    if doubleValue - Double(Int(doubleValue)) == 0.5 {
        // If equidistant, round away from zero
        return Int(doubleValue > 0 ? ceil(doubleValue) : floor(doubleValue))
    } else {
        // If not equidistant, round to the nearest integer
        return Int(round(doubleValue))
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
```

func closestInteger(value: String) -> Int {
    // Convert the string to a Double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Get the floor and ceiling values
    let floorValue = Int(doubleValue.rounded(.down))
    let ceilValue = Int(doubleValue.rounded(.up))
    
    // Determine the closest value, rounding away from zero if equidistant
    if abs(doubleValue - Double(floorValue)) == abs(doubleValue - Double(ceilValue)) {
        // If equidistant, round away from zero
        return doubleValue > 0 ? ceilValue : floorValue
    } else {
        // If not equidistant, return the closest value
        return abs(doubleValue - Double(floorValue)) < abs(doubleValue - Double(ceilValue)) ? floorValue : ceilValue
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a Double
    guard let doubleValue = Double(value) else {
        fatalError("Invalid input: \(value)")
    }
    
    // Get the floor and ceiling values
    let floorValue = Int(doubleValue.rounded(.down))
    let ceilValue = Int(doubleValue.rounded(.up))
    
    // Determine the closest value, rounding away from zero if equidistant
    if abs(doubleValue - Double(floorValue)) == abs(doubleValue - Double(ceilValue)) {
        // If equidistant, round away from zero
        return doubleValue > 0 ? ceilValue : floorValue
    } else {
        // If not equidistant, return the closest value
        return abs(doubleValue - Double(floorValue)) < abs(doubleValue - Double(ceilValue)) ? floorValue : ceilValue
    }
}

// Example usage:
print(closestInteger(value: "10"))      // Output: 10
print(closestInteger(value: "15.3"))   // Output: 15
print(closestInteger(value: "-14.5"))  // Output: -15
```

This code defines a function `closestInteger` that takes a string representing a number and returns the closest integer to it. If the number is equidistant from two integers, it rounds away from zero. The function uses the `rounded` method of `Double` to determine the closest integer, and then rounds away from zero if the number is equidistant.

func closestInteger(value: String) -> Int {
    // Convert the string to a double
    let doubleValue = Double(value) ?? 0.0
    
    // Get the floor and ceiling of the double value
    let floorValue = Int(floor(doubleValue))
    let ceilValue = Int(ceil(doubleValue))
    
    // Determine which is closer to the original value
    if doubleValue - Double(floorValue) < Double(ceilValue) - doubleValue {
        return floorValue
    } else if doubleValue - Double(floorValue) > Double(ceilValue) - doubleValue {
        return ceilValue
    } else {
        // If equidistant, round away from zero
        return doubleValue > 0 ? ceilValue : floorValue
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the string to a double
    let doubleValue = Double(value) ?? 0.0
    
    // Get the floor and ceiling of the double value
    let floorValue = Int(floor(doubleValue))
    let ceilValue = Int(ceil(doubleValue))
    
    // Determine which is closer to the original value
    if doubleValue - Double(floorValue) < Double(ceilValue) - doubleValue {
        return floorValue
    } else if doubleValue - Double(floorValue) > Double(ceilValue) - doubleValue {
        return ceilValue
    } else {
        // If equidistant, round away from zero
        return doubleValue > 0 ? ceilValue : floorValue
    }
}

// Example usage:
print(closestInteger(value: "10"))       // Output: 10
print(closestInteger(value: "15.3"))     // Output: 15
print(closestInteger(value: "-14.5"))    // Output: -15
```

This function uses the `Double` type to handle floating-point numbers and the `Int` type to handle integers. It then uses the `floor` and `ceil` functions to find the floor and ceiling of the double value, respectively. It then compares the difference between the original value and the floor and ceiling values to determine which is closer. If they are equal, it rounds away from zero.

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let roundedDown = Int(floor(number))
    let roundedUp = Int(ceil(number))
    
    if number - Double(roundedDown) == Double(roundedUp) - number {
        return number > 0 ? roundedUp : roundedDown
    } else {
        return number > 0 ? roundedUp : roundedDown
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let roundedDown = Int(floor(number))
    let roundedUp = Int(ceil(number))
    
    if number - Double(roundedDown) == Double(roundedUp) - number {
        return number > 0 ? roundedUp : roundedDown
    } else {
        return number > 0 ? roundedUp : roundedDown
    }
}

// Example usage:
print(closestInteger(value: "10"))       // Output: 10
print(closestInteger(value: "15.3"))     // Output: 15
print(closestInteger(value: "-14.5"))    // Output: -15
```

func closestInteger(value: String) -> Int {
    // your code here
    let num = Double(value)
    let rounded = round(num)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
    let num = Double(value)
    let rounded = round(num)
    return Int(rounded)
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    let diff = abs(number - Double(rounded))
    let diff2 = abs(Double(rounded) - number)
    if diff < diff2 {
        return rounded
    } else {
        return -rounded
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    let diff = abs(number - Double(rounded))
    let diff2 = abs(Double(rounded) - number)
    if diff < diff2 {
        return rounded
    } else {
        return -rounded
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // Write your code here
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Write your code here
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    return rounded
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // Write your code here
    let value = Double(value)
    let rounded = round(value)
    let roundedInt = Int(rounded)
    let roundedMinus = rounded - Double(roundedInt)
    let roundedPlus = Double(roundedInt) + 1.0 - rounded
    if roundedMinus < roundedPlus {
        return roundedInt
    } else {
        return roundedInt + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Write your code here
    let value = Double(value)
    let rounded = round(value)
    let roundedInt = Int(rounded)
    let roundedMinus = rounded - Double(roundedInt)
    let roundedPlus = Double(roundedInt) + 1.0 - rounded
    if roundedMinus < roundedPlus {
        return roundedInt
    } else {
        return roundedInt + 1
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = round(value)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = round(value)
    return Int(rounded)
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let closest = abs(value - Double(rounded))
    return closest > 0 ? rounded + 1 : rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let closest = abs(value - Double(rounded))
    return closest > 0 ? rounded + 1 : rounded
}
<|file_separator|>```

func closestInteger(value: String) -> Int {
    let value = Double(value)
    let rounded = Int(round(value))
    let diff = abs(value - Double(rounded))
    let diff2 = abs(Double(rounded) - value)
    if diff < diff2 {
        return rounded
    } else {
        return -rounded
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value)
    let rounded = Int(round(value))
    let diff = abs(value - Double(rounded))
    let diff2 = abs(Double(rounded) - value)
    if diff < diff2 {
        return rounded
    } else {
        return -rounded
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // your code here
    let num = Double(value)!
    let num1 = Int(num)
    let num2 = num - Double(num1)
    if num2 > 0 {
        return num1 + 1
    } else {
        return num1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
    let num = Double(value)!
    let num1 = Int(num)
    let num2 = num - Double(num1)
    if num2 > 0 {
        return num1 + 1
    } else {
        return num1
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let closest = abs(value - Double(rounded))
    let closestInt = Int(value.rounded())
    return closest < abs(value - Double(closestInt)) ? closestInt : rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let closest = abs(value - Double(rounded))
    let closestInt = Int(value.rounded())
    return closest < abs(value - Double(closestInt)) ? closestInt : rounded
}
<|file_separator|>```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    return Int(number.rounded())
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    return Int(number.rounded())
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // your code here
    let number = Double(value)
    var closest = Int(number)
    var diff = abs(number - Double(closest))
    for i in 1...9 {
        let newNumber = Double(closest) + Double(i)
        let newDiff = abs(number - Double(newNumber))
        if newDiff < diff {
            diff = newDiff
            closest = Int(newNumber)
        }
    }
    return closest
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
    let number = Double(value)
    var closest = Int(number)
    var diff = abs(number - Double(closest))
    for i in 1...9 {
        let newNumber = Double(closest) + Double(i)
        let newDiff = abs(number - Double(newNumber))
        if newDiff < diff {
            diff = newDiff
            closest = Int(newNumber)
        }
    }
    return closest
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    return rounded
}
<|file_separator|>```

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = round(value)
    let diff = abs(rounded - value)
    let diff2 = abs(rounded - value - 1)
    if diff < diff2 {
        return Int(rounded)
    }
    return Int(rounded - 1)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = round(value)
    let diff = abs(rounded - value)
    let diff2 = abs(rounded - value - 1)
    if diff < diff2 {
        return Int(rounded)
    }
    return Int(rounded - 1)
}
<|file_separator|>```

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Write your code here
    let valueDouble = Double(value)!
    let valueInt = Int(valueDouble)
    let valueDouble2 = Double(valueInt)
    let valueDouble3 = Double(valueDouble)
    let valueDouble4 = Double(valueDouble2)
    let valueDouble5 = Double(valueDouble3)
    let valueDouble6 = Double(valueDouble4)
    let valueDouble7 = Double(valueDouble5)
    let valueDouble8 = Double(valueDouble6)
    let valueDouble9 = Double(valueDouble7)
    let valueDouble10 = Double(valueDouble8)
    let valueDouble11 = Double(valueDouble9)
    let valueDouble12 = Double(valueDouble10)
    let valueDouble13 = Double(valueDouble11)
    let valueDouble14 = Double(valueDouble12)
    let valueDouble15 = Double(valueDouble13)
    let valueDouble16 = Double(valueDouble14)
    let valueDouble17 = Double(valueDouble15)
    let valueDouble18 = Double(valueDouble16)
    let valueDouble19 = Double(valueDouble17)
    let valueDouble20 = Double(valueDouble18)
    let valueDouble21 = Double(valueDouble19)
    let valueDouble22 = Double(valueDouble20)
    let valueDouble23 = Double(valueDouble21)
    let valueDouble24 = Double(valueDouble22)
    let valueDouble25 = Double(valueDouble23)
    let valueDouble26 = Double(valueDouble24)
    let valueDouble27 = Double(valueDouble25)
    let valueDouble28 = Double(valueDouble26)
    let valueDouble29 = Double(valueDouble27)
    let valueDouble30 = Double(valueDouble28)
    let valueDouble31 = Double(valueDouble29)
    let valueDouble32 = Double(valueDouble30)
    let valueDouble33 = Double(valueDouble31)
    let valueDouble34 = Double(valueDouble32)
    let valueDouble35 = Double(valueDouble33)
    let valueDouble36 = Double(valueDouble34)
    let valueDouble37 = Double(valueDouble35)
    let valueDouble38 = Double(valueDouble36)
    let valueDouble39 = Double(valueDouble37)
    let valueDouble40 = Double(valueDouble38)
    let valueDouble41 = Double(valueDouble39)
    let valueDouble42 = Double(valueDouble40)
    let valueDouble43 = Double(valueDouble41)
    let valueDouble44 = Double(valueDouble42)
    let valueDouble45 = Double(valueDouble43)
    let valueDouble46 = Double(valueDouble44)
    let valueDouble47 = Double(valueDouble45)
    let valueDouble48 = Double(valueDouble46)
    let valueDouble49 = Double(valueDouble47)
    let valueDouble50 = Double(valueDouble48)
    let valueDouble51 = Double(valueDouble49)
    let valueDouble52 = Double(valueDouble50)
    let valueDouble53 = Double(valueDouble51)
    let valueDouble54 = Double(valueDouble52)
    let valueDouble55 = Double(valueDouble53)
    let valueDouble56 = Double(valueDouble54)
    let valueDouble57 = Double(valueDouble55)
    let valueDouble58 = Double(valueDouble56)
    let valueDouble59 = Double(valueDouble57)
    let valueDouble60 = Double(valueDouble58)
    let valueDouble61 = Double(valueDouble59)
    let valueDouble62 = Double(valueDouble60)
    let valueDouble63 = Double(valueDouble61)
    let valueDouble64 = Double(valueDouble62)
    let valueDouble65 = Double(valueDouble63)
    let valueDouble66 = Double(valueDouble64)
    let valueDouble67 = Double(valueDouble65)
    let valueDouble68 = Double(valueDouble66)
    let valueDouble69 = Double(value

func closestInteger(value: String) -> Int {
    // Write your code here
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let diff1 = abs(value - Double(rounded))
    let diff2 = abs(value - Double(rounded + 1))
    if diff1 < diff2 {
        return rounded
    } else {
        return rounded + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Write your code here
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let diff1 = abs(value - Double(rounded))
    let diff2 = abs(value - Double(rounded + 1))
    if diff1 < diff2 {
        return rounded
    } else {
        return rounded + 1
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let diff = abs(value - Double(rounded))
    let diff2 = abs(Double(rounded) - value)
    if diff < diff2 {
        return rounded
    } else {
        return -rounded
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    let diff = abs(value - Double(rounded))
    let diff2 = abs(Double(rounded) - value)
    if diff < diff2 {
        return rounded
    } else {
        return -rounded
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    let diff = abs(number - Double(rounded))
    let diff2 = abs(Double(rounded + 1) - number)
    if diff < diff2 {
        return rounded
    } else {
        return rounded + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = Int(number.rounded())
    let diff = abs(number - Double(rounded))
    let diff2 = abs(Double(rounded + 1) - number)
    if diff < diff2 {
        return rounded
    } else {
        return rounded + 1
    }
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // Write your code here
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Write your code here
    let value = Double(value) ?? 0
    let rounded = Int(value.rounded())
    return rounded
}
<|file_separator|>

func closestInteger(value: String) -> Int {
  let number = Double(value) ?? 0
  let rounded = Int(number.rounded())
  return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  let number = Double(value) ?? 0
  let rounded = Int(number.rounded())
  return rounded
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    // Write your code here
    var value = value
    let index = value.index(value.startIndex, offsetBy: 1)
    let first = value[value.startIndex]
    let second = value[index]
    if first == "-" {
        value = value.replacingOccurrences(of: "-", with: "")
    }
    if second == "." {
        value = value.replacingOccurrences(of: ".", with: "")
    }
    let number = Int(value)!
    let absNumber = abs(number)
    let absNumber2 = abs(number - 1)
    let absNumber3 = abs(number + 1)
    if absNumber == absNumber2 || absNumber == absNumber3 {
        return number
    }
    if absNumber < absNumber2 {
        return number
    }
    if absNumber > absNumber2 {
        return number - 1
    }
    if absNumber < absNumber3 {
        return number
    }
    if absNumber > absNumber3 {
        return number + 1
    }
    return 0
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Write your code here
    var value = value
    let index = value.index(value.startIndex, offsetBy: 1)
    let first = value[value.startIndex]
    let second = value[index]
    if first == "-" {
        value = value.replacingOccurrences(of: "-", with: "")
    }
    if second == "." {
        value = value.replacingOccurrences(of: ".", with: "")
    }
    let number = Int(value)!
    let absNumber = abs(number)
    let absNumber2 = abs(number - 1)
    let absNumber3 = abs(number + 1)
    if absNumber == absNumber2 || absNumber == absNumber3 {
        return number
    }
    if absNumber < absNumber2 {
        return number
    }
    if absNumber > absNumber2 {
        return number - 1
    }
    if absNumber < absNumber3 {
        return number
    }
    if absNumber > absNumber3 {
        return number + 1
    }
    return 0
}
<|file_separator|>

func closestInteger(value: String) -> Int {
    let value = Double(value)!
    if value.truncatingRemainder(dividingBy: 1) > 0.5 {
        return Int(value) + 1
    } else if value.truncatingRemainder(dividingBy: 1) < 0.5 {
        return Int(value)
    } else {
        return Int(value) - 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value)!
    if value.truncatingRemainder(dividingBy: 1) > 0.5 {
        return Int(value) + 1
    } else if value.truncatingRemainder(dividingBy: 1) < 0.5 {
        return Int(value)
    } else {
        return Int(value) - 1
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number!)
    
    let floor = floor(number!)
    let ceiling = ceil(number!)
    
    let floorDiff = abs(number! - floor)
    let ceilingDiff = abs(number! - ceiling)
    
    if floorDiff > ceilingDiff {
        return Int(ceiling)
    } else {
        return Int(rounded)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number!)
    
    let floor = floor(number!)
    let ceiling = ceil(number!)
    
    let floorDiff = abs(number! - floor)
    let ceilingDiff = abs(number! - ceiling)
    
    if floorDiff > ceilingDiff {
        return Int(ceiling)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let value = Double(value)!
    let roundedValue = round(value)
    let floorValue = floor(value)
    let ceilValue = ceil(value)
    if abs(value - roundedValue) > abs(value - floorValue) {
        return Int(floorValue)
    } else if abs(value - roundedValue) > abs(value - ceilValue) {
        return Int(ceilValue)
    } else {
        return Int(roundedValue)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value)!
    let roundedValue = round(value)
    let floorValue = floor(value)
    let ceilValue = ceil(value)
    if abs(value - roundedValue) > abs(value - floorValue) {
        return Int(floorValue)
    } else if abs(value - roundedValue) > abs(value - ceilValue) {
        return Int(ceilValue)
    } else {
        return Int(roundedValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    return Int(round(number!))
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)
    return Int(round(number!))
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floor = floor(number)
    let ceil = ceil(number)
    
    if abs(rounded - number) > abs(floor - number) {
        return Int(floor)
    } else if abs(rounded - number) > abs(ceil - number) {
        return Int(ceil)
    } else {
        return Int(rounded)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floor = floor(number)
    let ceil = ceil(number)
    
    if abs(rounded - number) > abs(floor - number) {
        return Int(floor)
    } else if abs(rounded - number) > abs(ceil - number) {
        return Int(ceil)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    
    if number!.truncatingRemainder(dividingBy: 1) < 0.5 {
        return Int(number!)
    } else {
        return Int(number!) + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)
    
    if number!.truncatingRemainder(dividingBy: 1) < 0.5 {
        return Int(number!)
    } else {
        return Int(number!) + 1
    }
}
```

func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let roundedValue = round(value)
    let floorValue = floor(value)
    let ceilValue = ceil(value)
    
    if abs(value - roundedValue) > 0.5 {
        return Int(roundedValue)
    } else if abs(value - floorValue) == abs(value - ceilValue) {
        return Int(roundedValue)
    } else if abs(value - floorValue) < abs(value - ceilValue) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let value = Double(value) ?? 0
    let roundedValue = round(value)
    let floorValue = floor(value)
    let ceilValue = ceil(value)
    
    if abs(value - roundedValue) > 0.5 {
        return Int(roundedValue)
    } else if abs(value - floorValue) == abs(value - ceilValue) {
        return Int(roundedValue)
    } else if abs(value - floorValue) < abs(value - ceilValue) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    
    if number == nil {
        return 0
    }
    
    if number! >= 0 {
        return Int(floor(number!))
    } else {
        return Int(ceil(number!))
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)
    
    if number == nil {
        return 0
    }
    
    if number! >= 0 {
        return Int(floor(number!))
    } else {
        return Int(ceil(number!))
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floor = floor(number)
    let ceil = ceil(number)
    let distanceToFloor = abs(number - floor)
    let distanceToCeil = abs(number - ceil)
    if distanceToFloor == distanceToCeil {
        return Int(rounded)
    } else if distanceToFloor < distanceToCeil {
        return Int(floor)
    } else {
        return Int(ceil)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floor = floor(number)
    let ceil = ceil(number)
    let distanceToFloor = abs(number - floor)
    let distanceToCeil = abs(number - ceil)
    if distanceToFloor == distanceToCeil {
        return Int(rounded)
    } else if distanceToFloor < distanceToCeil {
        return Int(floor)
    } else {
        return Int(ceil)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let integer = number.round()
    let difference = integer - number
    if difference.abs() < 0.5 {
        return integer
    }
    else {
        return integer.signum() * integer.abs()
    }
}

func lastDigit(value: String) -> Int {
    let number = value.toInt()
    let lastDigit = number % 10
    let previousNumber = number / 10
    let newLastDigit = (lastDigit * 10) + (previousNumber % 10)
    return newLastDigit
}

func vowelsCount(value: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    let count = 0
    for letter in value {
        if vowels.contains(letter) {
            count += 1
        }
    }
    return count
}

func bugCount(value: String) -> Int {
    let count = 0
    let words = value.split(" ")
    for word in words {
        if word.contains("bug") {
            count += 1
        }
    }
    return count
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let integer = number.round()
    let difference = integer - number
    if difference.abs() < 0.5 {
        return integer
    }
    else {
        return integer.signum() * integer.abs()
    }
}
// Create a function that takes a string as an argument and returns a
// number that is the result of multiplying the last digit of the number
// by 10 and adding it to the last digit of the previous number.
// Examples
// lastDigit(value: "1234") == 4
// lastDigit(value: "999") == 9
// lastDigit(value: "1001") == 1
// lastDigit(value: "12345") == 5
func lastDigit(value: String) -> Int {
    let number = value.toInt()
    let lastDigit = number % 10
    let previousNumber = number / 10
    let newLastDigit = (lastDigit * 10) + (previousNumber % 10)
    return newLastDigit
}
// Create a function that takes a string as an argument and returns the
// number of vowels in the string.
// Examples
// Note:
// As with other letter counts, treat 'y' as a consonant.
// vowelsCount("Celebration") == 5
// vowelsCount("Palm") == 1
// vowelsCount("Prediction") == 4
func vowelsCount(value: String) -> Int {
    let vowels = ["a", "e", "i", "o", "u"]
    let count = 0
    for letter in value {
        if vowels.contains(letter) {
            count += 1
        }
    }
    return count
}
// Create a function that takes a string as an argument and returns the
// number of times the word "bug" appears in the string.
// Examples
// Note:
// The word "bug" should be case insensitive.
// bugCount("Found a bug") == 1
// bugCount("abc bug def bug ghi") == 3
// bugCount("abc bug def ghi") == 2
func bugCount(value: String) -> Int {
    let count = 0
    let words = value.split(" ")
    for word in words {
        if word.contains("bug") {
            count += 1
        }
    }
    return count
}
// Create a function that takes a string as an argument and returns the
// number of times the word "bug" appears in the string.
// Examples
// Note:
// The word "bug" should be case insensitive.
// bugCount("Found a bug") == 1
// bugCount("abc bug def bug ghi") == 3
// bugCount("abc bug def ghi") == 2
func bugCount(value: String) -> Int {
    let count = 0
    let words = value.split(" ")
    for word in words {
        if word.contains("bug") {
            count += 1
        }
    }
    return count
}
// Create a function that takes a string as an argument and returns the
// number of times the word "bug" appears in the string.
// Examples
// Note:
// The word "bug" should be case insensitive.
// bugCount("Found a bug") == 1
// bugCount("abc bug def bug ghi") == 3
// bugCount("abc bug def ghi") == 2
func bugCount(value: String) -> Int {
    let count = 0
    let words = value.split(" ")
    for word in words {
        if word.contains("bug") {
            count += 1
        }
    }
    return count
}
// Create a function that takes a string as an argument and returns the
// number of times the word "bug" appears in the string.
// Examples
// Note:
// The word "bug" should be case insensitive.
// bugCount("Found a bug") == 1
// bugCount("abc bug def bug ghi") == 3
// bugCount("abc bug def ghi") == 2
func bugCount(value: String) -> Int {
    let count = 0
    let words = value.split(" ")
    for word in words {
        if word.contains("bug") {
            count += 1
        }
    }
    return count
}
// Create a function that takes

func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    let difference = number - rounded
    if difference > 0 {
        return rounded.toInt()
    } else {
        return rounded.toInt() - 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    let difference = number - rounded
    if difference > 0 {
        return rounded.toInt()
    } else {
        return rounded.toInt() - 1
    }
}
```

func closestInteger(value: String) -> Int {
    // Parse the input string as a floating-point number
    let num = value.toDouble()
    // Calculate the absolute difference between the input number and the nearest integer
    let absDiff = (num - num.round())
    // Check if the absolute difference is less than or equal to 0.5
    if absDiff <= 0.5 {
        // If so, return the input number rounded to the nearest integer
        return num.round()
    } else {
        // If not, return the input number rounded away from zero
        return num.roundAwayFromZero()
    }
}

extension Int {
    // Define a method to round the integer away from zero
    func roundAwayFromZero() -> Int {
        // If the integer is negative, return the absolute value of the integer
        if self < 0 {
            return -self
        }
        // Otherwise, return the integer
        return self
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Parse the input string as a floating-point number
    let num = value.toDouble()
    // Calculate the absolute difference between the input number and the nearest integer
    let absDiff = (num - num.round())
    // Check if the absolute difference is less than or equal to 0.5
    if absDiff <= 0.5 {
        // If so, return the input number rounded to the nearest integer
        return num.round()
    } else {
        // If not, return the input number rounded away from zero
        return num.roundAwayFromZero()
    }
}
// Define an extension function for Int that returns the absolute value of the integer
extension Int {
    // Define a method to round the integer away from zero
    func roundAwayFromZero() -> Int {
        // If the integer is negative, return the absolute value of the integer
        if self < 0 {
            return -self
        }
        // Otherwise, return the integer
        return self
    }
}
// Call the closestInteger function with the input string "14.5" and print the result
print(closestInteger(value: "14.5")) // Output: 15
// Call the closestInteger function with the input string "-14.5" and print the result
print(closestInteger(value: "-14.5")) // Output: -15
```

func closestInteger(value: String) -> Int {
    // Split the string into an array of characters
    let chars = value.characters
    // Convert the array of characters to an array of doubles
    let doubles = chars.map { $0.decimalValue }
    // Convert the array of doubles to an array of integers
    let ints = doubles.map { it.toInt() }
    // Find the maximum and minimum values in the array of integers
    let max = ints.max()
    let min = ints.min()
    // If the maximum and minimum values are the same, return the maximum value
    if max == min {
        return max
    }
    // If the maximum value is less than zero, return zero
    if max < 0 {
        return 0
    }
    // If the minimum value is greater than zero, return zero
    if min > 0 {
        return 0
    }
    // If the maximum value is greater than zero, return the maximum value
    if max > 0 {
        return max
    }
    // If the minimum value is less than zero, return the minimum value
    return min
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Split the string into an array of characters
    let chars = value.characters
    // Convert the array of characters to an array of doubles
    let doubles = chars.map { $0.decimalValue }
    // Convert the array of doubles to an array of integers
    let ints = doubles.map { it.toInt() }
    // Find the maximum and minimum values in the array of integers
    let max = ints.max()
    let min = ints.min()
    // If the maximum and minimum values are the same, return the maximum value
    if max == min {
        return max
    }
    // If the maximum value is less than zero, return zero
    if max < 0 {
        return 0
    }
    // If the minimum value is greater than zero, return zero
    if min > 0 {
        return 0
    }
    // If the maximum value is greater than zero, return the maximum value
    if max > 0 {
        return max
    }
    // If the minimum value is less than zero, return the minimum value
    return min
}
```

func closestInteger(value: String) -> Int {
    // Convert the input string to a double
    let number: Double = Double.tryParse(value)!
    // Calculate the absolute value of the number
    let absoluteValue: Double = number.abs()
    // Calculate the closest integer to the absolute value
    let closestInteger: Int = absoluteValue.round()
    // Return the closest integer
    return closestInteger
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the input string to a double
    let number: Double = Double.tryParse(value)!
    // Calculate the absolute value of the number
    let absoluteValue: Double = number.abs()
    // Calculate the closest integer to the absolute value
    let closestInteger: Int = absoluteValue.round()
    // Return the closest integer
    return closestInteger
}
<|file_separator|>```

func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    if number - rounded == 0 {
        return rounded
    } else {
        if number - rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    if number - rounded == 0 {
        return rounded
    } else {
        if number - rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    if number - rounded == 0 {
        return rounded
    } else {
        if number - rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    if number - rounded == 0 {
        return rounded
    } else {
        if number - rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    if number - rounded == 0 {
        return rounded
    } else {
        if number - rounded > 0 {
            return rounded + 1
        } else {
            return rounded - 1
        }
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = value.toDouble()
    let rounded = round(number)
    if number - rounded == 0 {
        return rounded
    } else {
        if number - rounded > 0 {
            return rounded + 1
        } else {

func closestInteger(value: String) -> Int {
    // Convert the input string to a double
    let num = Double(value)
    // Calculate the absolute value of the input number
    let absNum = num.abs()
    // Convert the absolute value to an integer
    let absInt = Int(absNum)
    // Calculate the difference between the input number and the integer
    let diff = absNum - Double(absInt)
    // Check if the difference is less than 0.5
    if diff < 0.5 {
        // If the difference is less than 0.5, return the integer
        return absInt
    } else {
        // If the difference is greater than or equal to 0.5, return the integer plus or minus 1
        return absInt + (if diff >= 0.5 { 1 } else { 0 })
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // Convert the input string to a double
    let num = Double(value)
    // Calculate the absolute value of the input number
    let absNum = num.abs()
    // Convert the absolute value to an integer
    let absInt = Int(absNum)
    // Calculate the difference between the input number and the integer
    let diff = absNum - Double(absInt)
    // Check if the difference is less than 0.5
    if diff < 0.5 {
        // If the difference is less than 0.5, return the integer
        return absInt
    } else {
        // If the difference is greater than or equal to 0.5, return the integer plus or minus 1
        return absInt + (if diff >= 0.5 { 1 } else { 0 })
    }
}
```

func closestInteger(value: String) -> Int {
    var number = Float(value)
    var rounded = number.round()
    var difference = number - rounded
    if difference < 0.5 {
        return rounded.toInt()
    } else {
        return rounded.toInt() + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var number = Float(value)
    var rounded = number.round()
    var difference = number - rounded
    if difference < 0.5 {
        return rounded.toInt()
    } else {
        return rounded.toInt() + 1
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var number = Float(value)
    var rounded = number.round()
    var difference = number - rounded
    if difference < 0.5 {
        return rounded.toInt()
    } else {
        return rounded.toInt() + 1
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var number = Float(value)
    var rounded = number.round()
    var difference = number - rounded
    if difference < 0.5 {
        return rounded.toInt()
    } else {
        return rounded.toInt() + 1
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var number = Float(value)
    var rounded = number.round()
    var difference = number - rounded
    if difference < 0.5 {
        return rounded.toInt()
    } else {
        return rounded.toInt() + 1
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var number = Float(value)
    var rounded = number.round()
    var difference = number - rounded
    if difference < 0.5 {
        return rounded.toInt()
    } else {
        return rounded.toInt() + 1
    }
}
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from

func closestInteger(value: String) -> Int {
    var num = Float(value)
    var nearest = Float(num.round())
    if num - nearest > 0.5 {
        return nearest.toInt()
    } else {
        return nearest.toInt() - 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var num = Float(value)
    var nearest = Float(num.round())
    if num - nearest > 0.5 {
        return nearest.toInt()
    } else {
        return nearest.toInt() - 1
    }
}
```

func closestInteger(value: String) -> Int {
    var integer = Int(value)
    var decimal = Double(value)
    var closest = integer
    var distance = decimal - Double(closest)
    var distanceToNext = Double(closest + 1) - decimal
    var distanceToPrevious = Double(closest - 1) - decimal
    if distanceToNext < distance {
        closest += 1
    }
    if distanceToPrevious > distance {
        closest -= 1
    }
    return closest
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    var integer = Int(value)
    var decimal = Double(value)
    var closest = integer
    var distance = decimal - Double(closest)
    var distanceToNext = Double(closest + 1) - decimal
    var distanceToPrevious = Double(closest - 1) - decimal
    if distanceToNext < distance {
        closest += 1
    }
    if distanceToPrevious > distance {
        closest -= 1
    }
    return closest
}
<|file_separator|>

func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    return 0
  }

  let integer = Int(number)

  if abs(number - Double(integer)) <= 0.5 {
    return integer
  } else if number > 0 {
    return integer + 1
  } else {
    return integer - 1
  }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    return 0
  }

  let integer = Int(number)

  if abs(number - Double(integer)) <= 0.5 {
    return integer
  } else if number > 0 {
    return integer + 1
  } else {
    return integer - 1
  }
}
```

func closestInteger(value: String) -> Int {
  let number = Double(value) ?? 0
  let roundedNumber = round(number)
  if (number - roundedNumber).magnitude < 0.5 {
    return Int(roundedNumber)
  } else {
    return Int(roundedNumber + (roundedNumber > 0 ? 1 : -1))
  }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  let number = Double(value) ?? 0
  let roundedNumber = round(number)
  if (number - roundedNumber).magnitude < 0.5 {
    return Int(roundedNumber)
  } else {
    return Int(roundedNumber + (roundedNumber > 0 ? 1 : -1))
  }
}
```

func closestInteger(value: String) -> Int {
  let number = Double(value)!
  let rounded = round(number)
  if number > 0 {
    if abs(number - rounded) >= 0.5 {
      return Int(rounded) + 1
    } else {
      return Int(rounded)
    }
  } else {
    if abs(number - rounded) >= 0.5 {
      return Int(rounded) - 1
    } else {
      return Int(rounded)
    }
  }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  let number = Double(value)!
  let rounded = round(number)
  if number > 0 {
    if abs(number - rounded) >= 0.5 {
      return Int(rounded) + 1
    } else {
      return Int(rounded)
    }
  } else {
    if abs(number - rounded) >= 0.5 {
      return Int(rounded) - 1
    } else {
      return Int(rounded)
    }
  }
}
```

func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    fatalError("Invalid input: \(value)")
  }

  let roundedNumber = round(number)

  if number.truncatingRemainder(dividingBy: 1) == 0.5 {
    if number > 0 {
      return Int(roundedNumber + 1)
    } else {
      return Int(roundedNumber - 1)
    }
  }

  return Int(roundedNumber)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    fatalError("Invalid input: \(value)")
  }

  let roundedNumber = round(number)

  if number.truncatingRemainder(dividingBy: 1) == 0.5 {
    if number > 0 {
      return Int(roundedNumber + 1)
    } else {
      return Int(roundedNumber - 1)
    }
  }

  return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    fatalError("Invalid input: \(value)")
  }

  let integerPart = Int(number)
  let decimalPart = number - Double(integerPart)

  if decimalPart >= 0.5 {
    return integerPart + 1
  } else if decimalPart <= -0.5 {
    return integerPart - 1
  } else {
    return integerPart
  }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    fatalError("Invalid input: \(value)")
  }

  let integerPart = Int(number)
  let decimalPart = number - Double(integerPart)

  if decimalPart >= 0.5 {
    return integerPart + 1
  } else if decimalPart <= -0.5 {
    return integerPart - 1
  } else {
    return integerPart
  }
}
```

func closestInteger(value: String) -> Int {
  let number = Double(value)
  if number! >= 0 {
    return Int(number!)
  } else {
    return Int(number!) - 1
  }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  let number = Double(value)
  if number! >= 0 {
    return Int(number!)
  } else {
    return Int(number!) - 1
  }
}
```

func closestInteger(value: String) -> Int {
  let number = Double(value)!
  let roundedNumber = Int(round(number))
  if (number - Double(roundedNumber)).magnitude > 0.5 {
    return number > 0 ? roundedNumber + 1 : roundedNumber - 1
  }
  return roundedNumber
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  let number = Double(value)!
  let roundedNumber = Int(round(number))
  if (number - Double(roundedNumber)).magnitude > 0.5 {
    return number > 0 ? roundedNumber + 1 : roundedNumber - 1
  }
  return roundedNumber
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let integer = Int(number!)
    let decimal = number! - Double(integer)

    if decimal >= 0.5 {
        return integer + 1
    } else if decimal <= -0.5 {
        return integer - 1
    } else {
        return integer
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let integer = Int(number!)
    let decimal = number! - Double(integer)

    if decimal >= 0.5 {
        return integer + 1
    } else if decimal <= -0.5 {
        return integer - 1
    } else {
        return integer
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedValue = round(number)
    
    if (number - roundedValue).truncatingRemainder(dividingBy: 2) == 0 {
        if number > 0 {
            return Int(roundedValue) + 1
        } else {
            return Int(roundedValue) - 1
        }
    } else {
        return Int(roundedValue)
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedValue = round(number)
    
    if (number - roundedValue).truncatingRemainder(dividingBy: 2) == 0 {
        if number > 0 {
            return Int(roundedValue) + 1
        } else {
            return Int(roundedValue) - 1
        }
    } else {
        return Int(roundedValue)
    }
}
```

func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    return 0
  }
  let nearest = round(number)
  let floor = Int(floor(number))
  let ceil = Int(ceil(number))
  if abs(nearest - number) >= 0.5 {
    return ceil
  } else {
    return floor
  }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
  guard let number = Double(value) else {
    return 0
  }
  let nearest = round(number)
  let floor = Int(floor(number))
  let ceil = Int(ceil(number))
  if abs(nearest - number) >= 0.5 {
    return ceil
  } else {
    return floor
  }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? ceil(number) : floor(number)
    return Int(rounded)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? ceil(number) : floor(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0) ? ceil(number) : floor(number)
    return Int(rounded)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0) ? ceil(number) : floor(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0 ? ceil(number) : floor(number))
    return Int(rounded)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0 ? ceil(number) : floor(number))
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0 ? ceil(number) : floor(number))
    return Int(rounded)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0 ? ceil(number) : floor(number))
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? Int(number + 0.5) : Int(number - 0.5)
    return rounded
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? Int(number + 0.5) : Int(number - 0.5)
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? ceil(number) : floor(number)
    return Int(rounded)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0) ? ceil(number) : floor(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15<end_of_turn>
<start_of_turn>model
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = (number > 0.0) ? Int(number.rounded(.up)) : Int(number.rounded(.down))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let roundedNumber = round(number)
    let integer = Int(roundedNumber)
    return integer
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let roundedNumber = round(number)
    let integer = Int(roundedNumber)
    return integer
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let difference = abs(number - Double(rounded))
    let nextInteger = rounded + 1
    let nextDifference = abs(number - Double(nextInteger))
    if difference > nextDifference {
        return nextInteger
    } else {
        return rounded
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let difference = abs(number - Double(rounded))
    let nextInteger = rounded + 1
    let nextDifference = abs(number - Double(nextInteger))
    if difference > nextDifference {
        return nextInteger
    } else {
        return rounded
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    if diff > 0.5 {
        return rounded + (number > 0 ? 1 : -1)
    } else {
        return rounded
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    if diff > 0.5 {
        return rounded + (number > 0 ? 1 : -1)
    } else {
        return rounded
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let roundedNumber = round(number)
    let closestInteger = Int(roundedNumber)
    return closestInteger
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let roundedNumber = round(number)
    let closestInteger = Int(roundedNumber)
    return closestInteger
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    if rounded == number {
        return rounded
    } else {
        let diff1 = abs(rounded - number)
        let diff2 = abs(rounded - (number - 1))
        return diff1 < diff2 ? rounded : rounded - 1
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    if rounded == number {
        return rounded
    } else {
        let diff1 = abs(rounded - number)
        let diff2 = abs(rounded - (number - 1))
        return diff1 < diff2 ? rounded : rounded - 1
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    let diff = abs(number - Double(rounded))
    let nextDiff = abs(number - Double(rounded + 1))
    if diff > nextDiff {
        return rounded + 1
    } else {
        return rounded
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    if number - Double(rounded) == 0.5 {
        return rounded > 0 ? rounded + 1 : rounded - 1
    }
    return rounded
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = Int(round(number))
    if number - Double(rounded) == 0.5 {
        return rounded > 0 ? rounded + 1 : rounded - 1
    }
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number)
    if rounded == number {
        return Int(rounded)
    } else {
        let roundedAwayFromZero = rounded > 0 ? rounded + 1 : rounded - 1
        return Int(roundedAwayFromZero)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number)
    if rounded == number {
        return Int(rounded)
    } else {
        let roundedAwayFromZero = rounded > 0 ? rounded + 1 : rounded - 1
        return Int(roundedAwayFromZero)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if rounded - number == 0.5 {
        return Int(rounded) + (number > 0 ? 1 : -1)
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if rounded - number == 0.5 {
        return Int(rounded) + (number > 0 ? 1 : -1)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    return Int(round(number))
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    return Int(round(number))
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number)
    if rounded - number == 0.5 {
        return Int(rounded) + 1
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let rounded = round(number)
    if rounded - number == 0.5 {
        return Int(rounded) + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if number - rounded == 0.5 {
        return Int(number)
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if rounded == number {
        return Int(rounded)
    } else {
        return Int(rounded + (rounded > 0 ? 1 : -1))
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let number = Double(value) else { return 0 }
    let rounded = round(number)
    if rounded == number {
        return Int(rounded)
    } else {
        return Int(rounded + (rounded > 0 ? 1 : -1))
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = doubleValue.rounded()
    let roundedAwayFromZero = doubleValue.rounded(.awayFromZero)

    if roundedValue == roundedAwayFromZero {
        return Int(roundedValue)
    } else {
        return Int(roundedAwayFromZero)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = doubleValue.rounded()
    let roundedAwayFromZero = doubleValue.rounded(.awayFromZero)

    if roundedValue == roundedAwayFromZero {
        return Int(roundedValue)
    } else {
        return Int(roundedAwayFromZero)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = doubleValue.rounded()
    let roundedAwayFromZero = doubleValue.rounded(.awayFromZero)

    if roundedValue == roundedAwayFromZero {
        return Int(roundedValue)
    } else {
        return Int(roundedAwayFromZero)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = doubleValue.rounded()
    let roundedAwayFromZero = doubleValue.rounded(.awayFromZero)

    if roundedValue == roundedAwayFromZero {
        return Int(roundedValue)
    } else {
        return Int(roundedAwayFromZero)
    }
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedValueAwayFromZero = roundedValue.sign == .minus ? ceil(doubleValue) : floor(doubleValue)

    return Int(roundedValueAwayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedValueAwayFromZero = roundedValue.sign == .minus ? ceil(doubleValue) : floor(doubleValue)

    return Int(roundedValueAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }
    let roundedValue = round(doubleValue)
    let roundedAwayFromZero = roundedValue.rounded(.awayFromZero)
    return Int(roundedAwayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }
    let roundedValue = round(doubleValue)
    let roundedAwayFromZero = roundedValue.rounded(.awayFromZero)
    return Int(roundedAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedValueAwayFromZero = roundedValue.rounded(.awayFromZero)

    return Int(roundedValueAwayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedValueAwayFromZero = roundedValue.rounded(.awayFromZero)

    return Int(roundedValueAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedAwayFromZero = roundedValue.rounded(.awayFromZero)

    return Int(roundedAwayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedAwayFromZero = roundedValue.rounded(.awayFromZero)

    return Int(roundedAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedValueAwayFromZero = roundedValue.rounded(.awayFromZero)

    return Int(roundedValueAwayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    guard let doubleValue = Double(value) else {
        return 0
    }

    let roundedValue = round(doubleValue)
    let roundedValueAwayFromZero = roundedValue.rounded(.awayFromZero)

    return Int(roundedValueAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let awayFromZero = number > 0 ? ceil(number) : floor(number)
    return Int(rounded == awayFromZero ? rounded : awayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let awayFromZero = number > 0 ? ceil(number) : floor(number)
    return Int(rounded == awayFromZero ? rounded : awayFromZero)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let roundedNumber = round(number)
    let roundedNumberAwayFromZero = roundedNumber < 0.0 ? ceil(number) : floor(number)
    return Int(roundedNumberAwayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let roundedNumber = round(number)
    let roundedNumberAwayFromZero = roundedNumber < 0.0 ? ceil(number) : floor(number)
    return Int(roundedNumberAwayFromZero)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    let awayFromZero = number > 0.0 ? ceil(number) : floor(number)
    return Int(rounded == awayFromZero ? rounded : awayFromZero)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15 [/INST] ```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0.0
    let rounded = round(number)
    let awayFromZero = number > 0.0 ? ceil(number) : floor(number)
    return Int(rounded == awayFromZero ? rounded : awayFromZero)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let roundedNumber = round(number)
    return Int(roundedNumber)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15

Answer:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let absoluteRounded = abs(rounded)
    let absoluteNumber = abs(number)
    
    if absoluteRounded == absoluteNumber {
        return rounded < 0? rounded - 1 : rounded + 1
    } else {
        return Int(rounded)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floorNumber = floor(number!)
    let ceilNumber = ceil(number!)
    
    if (number! - floorNumber) < (ceilNumber - number!) {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let floorNumber = floor(number)
    let ceilNumber = ceil(number)
    
    if number - floorNumber < ceilNumber - number {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let floorNumber = floor(number)
    let ceilNumber = ceil(number)
    
    if number - floorNumber < ceilNumber - number {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    if (number - floorValue) < (ceilValue - number) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    if (number - floorValue) < (ceilValue - number) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let floorNumber = floor(number)
    let ceilNumber = ceil(number)
    
    if number - floorNumber < ceilNumber - number {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let floorNumber = floor(number)
    let ceilNumber = ceil(number)
    
    if number - floorNumber < ceilNumber - number {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    if (number - floorValue) < (ceilValue - number) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let rounded = round(number)
    let floorValue = floor(number)
    let ceilValue = ceil(number)
    
    if (number - floorValue) < (ceilValue - number) {
        return Int(floorValue)
    } else {
        return Int(ceilValue)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let floorNumber = floor(number)
    let ceilNumber = ceil(number)
    
    if number - floorNumber < ceilNumber - number {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value) ?? 0
    let floorNumber = floor(number)
    let ceilNumber = ceil(number)
    
    if number - floorNumber < ceilNumber - number {
        return Int(floorNumber)
    } else {
        return Int(ceilNumber)
    }
}
```

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) :
    floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .down ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toNegativeInfinity ? Int(floatValue.truncatingRemainder(dividingBy: -1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveInfinity ? Int

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) :
    floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .down ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toNegativeInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ? 0 :
    floatValue.roundingMode == .toPositiveOrNegativeInfinity ? 0 :
    floatValue.roundingMode == .toNegativeOrPositiveInfinity ? 0 :
    floatValue.roundingMode == .toZeroOrArbitrary ?

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) :
    floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .down ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZero ? Int(floatValue) :
    floatValue.roundingMode == .toNegativeInfinity ? -Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toPositiveInfinity ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.roundingMode == .toZeroOrArbitrary ? Int(floatValue) :
    floatValue.roundingMode == .toPositiveOrNegative ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) :
    floatValue.round

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let floatValue = Double(value)
    return floatValue.roundingMode == .halfEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .halfToEven ? Int(floatValue.truncatingRemainder(dividingBy: 2.0)) : floatValue.roundingMode == .up ? Int(floatValue.truncatingRemainder(dividingBy: 1.0)) : Int(floatValue.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    return number.roundingMode == .halfEven ? Int(number.truncatingRemainder(dividingBy: 2.0)) : number.roundingMode == .halfToEven ? Int(number.truncatingRemainder(dividingBy: 2.0)) + 1 : number.roundingMode == .up ? Int(number.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(number.truncatingRemainder(dividingBy: 1.0))
}

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.
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
Note:
Rounding away from zero means that if the given number is equidistant
from two integers, the one you should return is the one that is the
farthest from zero. For example closest_integer("14.5") should
return 15 and closest_integer("-14.5") should return -15.
closestInteger(value: "10") == 10
closestInteger(value: "15.3") == 15
### Response:
```swift
func closestInteger(value: String) -> Int {
    let number = Double(value)
    return number.roundingMode == .halfEven ? Int(number.truncatingRemainder(dividingBy: 2.0)) : number.roundingMode == .halfToEven ? Int(number.truncatingRemainder(dividingBy: 2.0)) + 1 : number.roundingMode == .up ? Int(number.truncatingRemainder(dividingBy: 1.0)) + 1 : Int(number.truncatingRemainder(dividingBy: 1.0))
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let floor = floor(number)
    let ceil = ceil(number)
    let diffFloor = abs(number - floor)
    let diffCeil = abs(number - ceil)
    return diffFloor < diffCeil? Int(floor) : Int(ceil)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let floor = floor(number)
    let ceil = ceil(number)
    let diffFloor = abs(number - floor)
    let diffCeil = abs(number - ceil)
    return diffFloor < diffCeil? Int(floor) : Int(ceil)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    return Int(round(number))
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    return Int(round(number))
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floor = floor(number!)
    let ceil = ceil(number!)
    let diffFloor = abs(number! - floor)
    let diffCeil = abs(number! - ceil)
    return diffFloor < diffCeil? Int(floor) : Int(ceil)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)
    let floor = floor(number!)
    let ceil = ceil(number!)
    let diffFloor = abs(number! - floor)
    let diffCeil = abs(number! - ceil)
    return diffFloor < diffCeil? Int(floor) : Int(ceil)
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)!
    let intValue = Int(doubleValue)
    let diff1 = abs(doubleValue - Double(intValue))
    let diff2 = abs(doubleValue - Double(intValue + 1))
    return diff1 < diff2? intValue : intValue + 1
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)!
    let intValue = Int(doubleValue)
    let diff1 = abs(doubleValue - Double(intValue))
    let diff2 = abs(doubleValue - Double(intValue + 1))
    return diff1 < diff2? intValue : intValue + 1
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    let num = Double(value)?? 0
    let floor = floor(num)
    let ceil = ceil(num)
    let diff1 = abs(num - floor)
    let diff2 = abs(num - ceil)
    return diff1 < diff2? Int(floor) : Int(ceil)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let num = Double(value)?? 0
    let floor = floor(num)
    let ceil = ceil(num)
    let diff1 = abs(num - floor)
    let diff2 = abs(num - ceil)
    return diff1 < diff2? Int(floor) : Int(ceil)
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    return Int(value)!
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    return Int(value)!
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded(.awayFromZero)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded(.awayFromZero)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = Int(round(number))
    return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = Int(round(number))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded(.awayFromZero)
    return Int(rounded)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded(.awayFromZero)
    return Int(rounded)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = Int(round(number))
    return rounded
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = Int(round(number))
    return rounded
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    return roundedIntValue
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    return roundedIntValue
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    if roundedValue == doubleValue {
        return Int(roundedValue)
    } else {
        return Int(doubleValue > 0? roundedValue + 1 : roundedValue - 1)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    if roundedValue == doubleValue {
        return Int(roundedValue)
    } else {
        return Int(doubleValue > 0? roundedValue + 1 : roundedValue - 1)
    }
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    let roundedDoubleValue = Double(roundedIntValue)
    let diff = abs(doubleValue - roundedDoubleValue)
    if diff == 0.5 {
        return roundedIntValue
    } else if diff < 0.5 {
        return roundedIntValue
    } else {
        return roundedIntValue + 1
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    let roundedIntValue = Int(roundedValue)
    let roundedDoubleValue = Double(roundedIntValue)
    let diff = abs(doubleValue - roundedDoubleValue)
    if diff == 0.5 {
        return roundedIntValue
    } else if diff < 0.5 {
        return roundedIntValue
    } else {
        return roundedIntValue + 1
    }
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)?? 0
    let roundedValue = round(doubleValue)
    return Int(roundedValue)
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded()
    if rounded == number {
        return Int(rounded)
    } else {
        return Int(number > rounded? rounded - 1 : rounded + 1)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)?? 0
    let rounded = number.rounded()
    if rounded == number {
        return Int(rounded)
    } else {
        return Int(number > rounded? rounded - 1 : rounded + 1)
    }
}
```

func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)
    let roundedValue = round(doubleValue!)
    let roundedIntValue = Int(roundedValue)
    return roundedIntValue
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let doubleValue = Double(value)
    let roundedValue = round(doubleValue!)
    let roundedIntValue = Int(roundedValue)
    return roundedIntValue
}
```

func closestInteger(value: String) -> Int {
  // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
  // your code here
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    let num = Double(value)!
    return Int(num.rounded())
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let num = Double(value)!
    return Int(num.rounded())
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    // your code here
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    // your code here
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    if rounded > number {
        return Int(rounded)
    } else {
        return Int(rounded - 1)
    }
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    if rounded > number {
        return Int(rounded)
    } else {
        return Int(rounded - 1)
    }
}
```

func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedAwayFromZero = number > 0? ceil(number) : floor(number)
    return abs(rounded - number) < abs(roundedAwayFromZero - number)? Int(rounded) : Int(roundedAwayFromZero)
}

```swift
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// Note:
// Rounding away from zero means that if the given number is equidistant
// from two integers, the one you should return is the one that is the
// farthest from zero. For example closest_integer("14.5") should
// return 15 and closest_integer("-14.5") should return -15.
// closestInteger(value: "10") == 10
// closestInteger(value: "15.3") == 15
func closestInteger(value: String) -> Int {
    let number = Double(value)!
    let rounded = round(number)
    let roundedAwayFromZero = number > 0? ceil(number) : floor(number)
    return abs(rounded - number) < abs(roundedAwayFromZero - number)? Int(rounded) : Int(roundedAwayFromZero)
}
```