func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a) + (b * b) == (c * c)
}

func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a) + (b * b) == (c * c)
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    return str == str.reversed()
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that is the same forward and backward.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("is").count - 1
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("the").count - 1
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("and").count - 1
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("or").count - 1
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("not").count - 1
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("yes").count - 1
}

func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("no").count - 1
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

// Given a string, return the number of times "is" appears in the string.
// Example:
// numberOfTimes("is") == 2
// numberOfTimes("is is") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("is").count - 1
}

// Given a string, return the number of times "the" appears in the string.
// Example:
// numberOfTimes("the") == 2
// numberOfTimes("the the") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("the").count - 1
}

// Given a string, return the number of times "and" appears in the string.
// Example:
// numberOfTimes("and") == 2
// numberOfTimes("and and") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("and").count - 1
}

// Given a string, return the number of times "or" appears in the string.
// Example:
// numberOfTimes("or") == 2
// numberOfTimes("or or") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("or").count - 1
}

// Given a string, return the number of times "not" appears in the string.
// Example:
// numberOfTimes("not") == 2
// numberOfTimes("not not") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("not").count - 1
}

// Given a string, return the number of times "yes" appears in the string.
// Example:
// numberOfTimes("yes") == 2
// numberOfTimes("yes yes") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("yes").count - 1
}

// Given a string, return the number of times "no" appears in the string.
// Example:
// numberOfTimes("no") == 2
// numberOfTimes("no no") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("no").count - 1
}

// Given a string, return the number of times "yes" appears in the string.
// Example:
// numberOfTimes("yes") == 2
// numberOfTimes("yes yes") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("yes").count - 1
}

// Given a string, return the number of times "no" appears in the string.
// Example:
// numberOfTimes("no") == 2
// numberOfTimes("no no") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("no").count - 1
}

// Given a string, return the number of times "yes" appears in the string.
// Example:
// numberOfTimes("yes") == 2
// numberOfTimes("yes yes") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("yes").count - 1
}

// Given a string, return the number of times "no" appears in the string.
// Example:
// numberOfTimes("no") == 2
// numberOfTimes("no no") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("no").count - 1
}

// Given a string, return the number of times "yes" appears in the string.
// Example:
// numberOfTimes("yes") == 2
// numberOfTimes("yes yes") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("yes").count - 1
}

// Given a string, return the number of times "no" appears in the string.
// Example:
// numberOfTimes("no") == 2
// numberOfTimes("no no") == 3
func numberOfTimes(str: String) -> Int {
    return str.componentsSeparatedByString("no").count - 1
}

// Given a string, return the number of times "yes" appears in

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
  if (a*a + b*b == c*c) {
    return true
  } else {
    return false
  }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
  if (a*a + b*b == c*c) {
    return true
  } else {
    return false
  }
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a) {
        return true
    }
    return false
}

func palindrome(str: String) -> Bool {
    if str == String(str.reversed()) {
        return true
    }
    return false
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "a" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "b" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "c" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "d" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "e" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "f" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "g" {
            count += 1
        }
    }
    return count
}

func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "h" {
            count += 1
        }
    }
    return count
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a) {
        return true
    }
    return false
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that reads the same backwards as forwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    if str == String(str.reversed()) {
        return true
    }
    return false
}

// Given a string, return the number of times the character 'a' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "a" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'b' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "b" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'c' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "c" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'd' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "d" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'e' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "e" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'f' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "f" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'g' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "g" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'h' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "h" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times the character 'i' occurs in the string.
// Example:
// countChar("hello") == 1
// countChar("hello world") == 2
func countChar(str: String) -> Int {
    var count = 0
    for char in str {
        if char == "i" {

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a == 0 || b == 0 || c == 0 {
        return false
    }
    if a == b || b == c || a == c {
        return false
    }
    if a * a + b * b == c * c {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a == 0 || b == 0 || c == 0 {
        return false
    }
    if a == b || b == c || a == c {
        return false
    }
    if a * a + b * b == c * c {
        return true
    }
    return false
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

func countAm(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "a" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "m" {
                count += 1
            }
        }
    }
    return count
}

func countXyz(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "x" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "y" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "z" {
                    count += 1
                }
            }
        }
    }
    return count
}

func countCat(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "c" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "a" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "t" {
                    count += 1
                }
            }
        }
    }
    return count
}

func countDog(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "d" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "o" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "g" {
                    count += 1
                }
            }
        }
    }
    return count
}

func countFish(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "f" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "i" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "s" {
                    if str[str.index(str.startIndex, offsetBy: i+3)] == "h" {
                        count += 1
                    }
                }
            }
        }
    }
    return count
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am, am") == 1
func countAm(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "a" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "m" {
                count += 1
            }
        }
    }
    return count
}

// Given a string, return the number of times "xyz" appears in the string.
// Example:
// countXyz("xyz") == 1
// countXyz("xyzxyz") == 2
// countXyz("xyzxyzxyz") == 3
func countXyz(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "x" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "y" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "z" {
                    count += 1
                }
            }
        }
    }
    return count
}

// Given a string, return the number of times "cat" appears in the string.
// Example:
// countCat("cat") == 1
// countCat("catcat") == 2
// countCat("catcatcat") == 3
func countCat(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "c" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "a" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "t" {
                    count += 1
                }
            }
        }
    }
    return count
}

// Given a string, return the number of times "dog" appears in the string.
// Example:
// countDog("dog") == 1
// countDog("dogdog") == 2
// countDog("dogdogdog") == 3
func countDog(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "d" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "o" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "g" {
                    count += 1
                }
            }
        }
    }
    return count
}

// Given a string, return the number of times "fish" appears in the string.
// Example:
// countFish("fish") == 1
// countFish("fishfish") == 2
// countFish("fishfishfish") == 3
func countFish(str: String) -> Int {
    var count = 0
    for i in 0..<str.count {
        if str[str.index(str.startIndex, offsetBy: i)] == "f" {
            if str[str.index(str.startIndex, offsetBy: i+1)] == "i" {
                if str[str.index(str.startIndex, offsetBy: i+2)] == "s" {
                    if str[str.index(str.startIndex, offsetBy: i+3)] == "h" {
                        count += 1
                    }
                }
            }
        }
    }
    return count
}

// Given a string, return the number of times "cat" appears in the string.
// Example:
// countCat("cat") == 1
// countCat("catcat") == 2
// countCat("catcatcat") == 3
func countCat(str: String) -> Int

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    }
    return false
}

func isPalindrome(x: Int) -> Bool {
    let xString = String(x)
    let xArray = xString.map { String($0) }
    let xArrayReversed = xArray.reversed()
    let xArrayReversedString = xArrayReversed.joined()
    if xString == xArrayReversedString {
        return true
    }
    return false
}

func isPrime(x: Int) -> Bool {
    if x == 1 {
        return false
    }
    for i in 2...x {
        if x % i == 0 {
            return false
        }
    }
    return true
}

func isPerfect(x: Int) -> Bool {
    var sum = 0
    for i in 1...x {
        if x % i == 0 {
            sum += i
        }
    }
    if sum == x {
        return true
    }
    return false
}

func isHappy(x: Int) -> Bool {
    var x = x
    var sum = 0
    while x != 1 {
        sum = 0
        while x > 0 {
            let digit = x % 10
            sum += digit * digit
            x /= 10
        }
        x = sum
    }
    if x == 1 {
        return true
    }
    return false
}

func reverseString(s: String) -> String {
    let sArray = s.map { String($0) }
    let sArrayReversed = sArray.reversed()
    let sArrayReversedString = sArrayReversed.joined()
    return sArrayReversedString
}

func sumDigits(x: Int) -> Int {
    var x = x
    var sum = 0
    while x > 0 {
        let digit = x % 10
        sum += digit
        x /= 10
    }
    return sum
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    }
    return false
}

// Given an integer, return true if it is a palindrome, false otherwise.
// Example:
// isPalindrome(121) == true
// isPalindrome(123) == false
func isPalindrome(x: Int) -> Bool {
    let xString = String(x)
    let xArray = xString.map { String($0) }
    let xArrayReversed = xArray.reversed()
    let xArrayReversedString = xArrayReversed.joined()
    if xString == xArrayReversedString {
        return true
    }
    return false
}

// Given an integer, return true if it is a prime number, false otherwise.
// Example:
// isPrime(1) == false
// isPrime(2) == true
// isPrime(3) == true
// isPrime(4) == false
func isPrime(x: Int) -> Bool {
    if x == 1 {
        return false
    }
    for i in 2...x {
        if x % i == 0 {
            return false
        }
    }
    return true
}

// Given an integer, return true if it is a perfect number, false otherwise.
// A perfect number is a positive integer that is equal to the sum of its
// positive divisors, excluding the number itself.
// Example:
// isPerfect(6) == true
// isPerfect(28) == true
// isPerfect(496) == true
// isPerfect(12) == false
func isPerfect(x: Int) -> Bool {
    var sum = 0
    for i in 1...x {
        if x % i == 0 {
            sum += i
        }
    }
    if sum == x {
        return true
    }
    return false
}

// Given an integer, return true if it is a happy number, false otherwise.
// A happy number is a number defined by the following process:
// Starting with any positive integer, replace the number by the sum of the
// squares of its digits, and repeat the process until the number equals 1.
// If the number does not equal 1, then repeat the process until it
// reaches a number which has no digits.
// Example:
// isHappy(19) == true
// isHappy(10) == false
func isHappy(x: Int) -> Bool {
    var x = x
    var sum = 0
    while x != 1 {
        sum = 0
        while x > 0 {
            let digit = x % 10
            sum += digit * digit
            x /= 10
        }
        x = sum
    }
    if x == 1 {
        return true
    }
    return false
}

// Given a string, return the string with all the characters in reverse order.
// Example:
// reverseString("hello") == "olleh"
// reverseString("hello world") == "dlrow olleh"
func reverseString(s: String) -> String {
    let sArray = s.map { String($0) }
    let sArrayReversed = sArray.reversed()
    let sArrayReversedString = sArrayReversed.joined()
    return sArrayReversedString
}

// Given a string, return the string with all the characters in reverse order.
// Example:
// reverseString("hello") == "olleh"
// reverseString("hello world") == "dlrow olleh"
func reverseString(s: String) -> String {
    let sArray = s.map { String($0) }
    let sArrayReversed = sArray.reversed()
    let sArrayReversedString = sArrayReversed.joined()
    return sArrayReversedString
}

// Given an integer, return the sum of all the digits.
// Example:
// sumDigits(123) == 6
// sumDigits(12345) == 15
func sumDigits(x: Int) -> Int {
    var x = x
    var sum = 0
    while x > 0 {
        let digit = x % 10
        sum += digit
        x /= 10
    }
    return sum
}

// Given an integer, return the sum of all the digits.
// Example:
// sumDigits(123) == 6
// sumDigits(1

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    }
    return false
}

func isPalindrome(str: String) -> Bool {
    var str = str
    str = str.lowercased()
    str = str.replacingOccurrences(of: " ", with: "")
    for i in 0..<str.count / 2 {
        if str[str.startIndex] != str[str.index(str.startIndex, offsetBy: str.count - i - 1)] {
            return false
        }
    }
    return true
}

func countVowels(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for char in str {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            count += 1
        }
    }
    return count
}

func countConsonants(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for char in str {
        if char != "a" && char != "e" && char != "i" && char != "o" && char != "u" {
            count += 1
        }
    }
    return count
}

func countWords(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for char in str {
        if char == " " {
            count += 1
        }
    }
    return count + 1
}

func countPalindromes(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for word in str.components(separatedBy: " ") {
        if isPalindrome(str: word) {
            count += 1
        }
    }
    return count
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    }
    return false
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word that reads the same backwards as forwards.
// Example:
// isPalindrome("racecar") == true
// isPalindrome("hello") == false
func isPalindrome(str: String) -> Bool {
    var str = str
    str = str.lowercased()
    str = str.replacingOccurrences(of: " ", with: "")
    for i in 0..<str.count / 2 {
        if str[str.startIndex] != str[str.index(str.startIndex, offsetBy: str.count - i - 1)] {
            return false
        }
    }
    return true
}

// Given a string, return the number of vowels in the string.
// Example:
// countVowels("hello") == 2
// countVowels("aeiou") == 5
func countVowels(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for char in str {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of consonants in the string.
// Example:
// countConsonants("hello") == 2
// countConsonants("aeiou") == 0
func countConsonants(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for char in str {
        if char != "a" && char != "e" && char != "i" && char != "o" && char != "u" {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string.
// Example:
// countWords("hello") == 1
// countWords("hello world") == 2
func countWords(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for char in str {
        if char == " " {
            count += 1
        }
    }
    return count + 1
}

// Given a string, return the number of words in the string that are palindromes.
// A palindrome is a word that reads the same backwards as forwards.
// Example:
// countPalindromes("hello") == 0
// countPalindromes("racecar") == 1
// countPalindromes("racecar racecar") == 2
func countPalindromes(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for word in str.components(separatedBy: " ") {
        if isPalindrome(str: word) {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string that are palindromes.
// A palindrome is a word that reads the same backwards as forwards.
// Example:
// countPalindromes("hello") == 0
// countPalindromes("racecar") == 1
// countPalindromes("racecar racecar") == 2
func countPalindromes(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for word in str.components(separatedBy: " ") {
        if isPalindrome(str: word) {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of words in the string that are palindromes.
// A palindrome is a word that reads the same backwards as forwards.
// Example:
// countPalindromes("hello") == 0
// countPalindromes("racecar") == 1
// countPalindromes("racecar racecar") == 2
func countPalindromes(str: String) -> Int {
    var str = str
    str = str.lowercased()
    var count = 0
    for word in str.components(separatedBy: " ") {
        

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

func sumOfRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var sum = 0
    for i in 0..<nums.count {
        sum += nums[i]
        result.append(sum)
    }
    return result
}

func productOfLeft(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.append(product)
    }
    return result
}

func productOfRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.insert(product, at: 0)
    }
    return result
}

func productOfLeftAndRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.insert(product, at: 0)
    }
    for i in 0..<nums.count {
        product = 1
        for j in i+1..<nums.count {
            product *= nums[j]
        }
        result.append(product)
    }
    return result
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

// Given a list of integers, return a list of integers where each integer is the
// sum of the integers to the right of it.
// Example:
// sumOfRight(1, 2, 3, 4, 5) == [2, 5, 11, 12, 15]
// sumOfRight(1, 2, 3) == [2, 5, 6]
func sumOfRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var sum = 0
    for i in 0..<nums.count {
        sum += nums[i]
        result.append(sum)
    }
    return result
}

// Given a list of integers, return a list of integers where each integer is the
// product of the integers to the left of it.
// Example:
// productOfLeft(1, 2, 3, 4, 5) == [120, 60, 40, 30, 24]
// productOfLeft(1, 2, 3) == [6, 3, 2]
func productOfLeft(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.append(product)
    }
    return result
}

// Given a list of integers, return a list of integers where each integer is the
// product of the integers to the right of it.
// Example:
// productOfRight(1, 2, 3, 4, 5) == [120, 60, 40, 30, 24]
// productOfRight(1, 2, 3) == [6, 3, 2]
func productOfRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.insert(product, at: 0)
    }
    return result
}

// Given a list of integers, return a list of integers where each integer is the
// product of the integers to the left and right of it.
// Example:
// productOfLeftAndRight(1, 2, 3, 4, 5) == [120, 60, 40, 30, 24]
// productOfLeftAndRight(1, 2, 3) == [6, 3, 2]
func productOfLeftAndRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.insert(product, at: 0)
    }
    for i in 0..<nums.count {
        product = 1
        for j in i+1..<nums.count {
            product *= nums[j]
        }
        result.append(product)
    }
    return result
}

// Given a list of integers, return a list of integers where each integer is the
// product of the integers to the left and right of it.
// Example:
// productOfLeftAndRight(1, 2, 3, 4, 5) == [120, 60, 40, 30, 24]
// productOfLeftAndRight(1, 2, 3) == [6, 3, 2]
func productOfLeftAndRight(nums: Int...) -> [Int] {
    var result = [Int]()
    var product = 1
    for i in 0..<nums.count {
        product *= nums[i]
        result.insert(product, at: 0)
    }
    for i in 0..<nums.count {
        product = 1
        for j in 0..<i {
            product *= nums[j]
        }
        for j in i+1..<nums.count {
            product *= nums[j]
        }
        result.append

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

func firstLast(str: String) -> String {
    return str.dropFirst().dropLast()
}

func firstLast(str: String) -> String {
    return str.first! + str.dropFirst().dropLast() + str.last!
}

func firstLast3(str: String) -> String {
    return str.prefix(3) + str.suffix(3)
}

func midChar(str: String) -> String {
    return str.prefix(1) + str.dropFirst().dropLast().replacingOccurrences(of: str.dropFirst().dropLast(), with: "*") + str.last!
}

func firstLast2(str: String) -> String {
    return str.dropFirst().dropLast()
}

func firstLast2(str: String) -> String {
    return str.first! + str.dropFirst().dropLast() + str.last!
}

func firstLast2(str: String) -> String {
    return str.prefix(2) + str.suffix(2)
}

func midChar2(str: String) -> String {
    return str.prefix(1) + str.dropFirst().dropLast().dropFirst().dropLast() + str.last!
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

// Given a string, return a new string with the first and last char removed.
// Example:
// firstLast("hello") == "ello"
// firstLast("a") == "a"
// firstLast("ab") == "a"
func firstLast(str: String) -> String {
    return str.dropFirst().dropLast()
}

// Given a string, return a new string with the first char added at the end,
// and the last char added at the beginning.
// Example:
// firstLast("hello") == "ohelllo"
// firstLast("a") == "a"
// firstLast("ab") == "ba"
func firstLast(str: String) -> String {
    return str.first! + str.dropFirst().dropLast() + str.last!
}

// Given a string, return a new string with the first char added at the beginning,
// and the last char added at the end.
// Example:
// firstLast("hello") == "ohelllo"
// firstLast("a") == "a"
// firstLast("ab") == "ba"
func firstLast(str: String) -> String {
    return str.first! + str.dropFirst().dropLast() + str.last!
}

// Given a string, return a new string with the first 3 chars added at the
// beginning and the last 3 chars added at the end.
// Example:
// firstLast3("hello") == "hellol"
// firstLast3("a") == "a"
// firstLast3("ab") == "abab"
func firstLast3(str: String) -> String {
    return str.prefix(3) + str.suffix(3)
}

// Given a string, return a new string with the 2 chars in the middle replaced
// by '*'.
// Example:
// midChar("hello") == "h*ll"
// midChar("a") == "a"
// midChar("ab") == "a"
func midChar(str: String) -> String {
    return str.prefix(1) + str.dropFirst().dropLast().replacingOccurrences(of: str.dropFirst().dropLast(), with: "*") + str.last!
}

// Given a string, return a new string with the first and last chars
// removed.
// Example:
// firstLast2("hello") == "ell"
// firstLast2("a") == "a"
// firstLast2("ab") == "a"
func firstLast2(str: String) -> String {
    return str.dropFirst().dropLast()
}

// Given a string, return a new string with the first char added at the
// beginning and the last char added at the end.
// Example:
// firstLast2("hello") == "ohelllo"
// firstLast2("a") == "a"
// firstLast2("ab") == "ba"
func firstLast2(str: String) -> String {
    return str.first! + str.dropFirst().dropLast() + str.last!
}

// Given a string, return a new string with the first 2 chars added at the
// beginning and the last 2 chars added at the end.
// Example:
// firstLast2("hello") == "hellol"
// firstLast2("a") == "a"
// firstLast2("ab") == "abab"
func firstLast2(str: String) -> String {
    return str.prefix(2) + str.suffix(2)
}

// Given a string, return a new string with the 2 chars in the middle
// removed, so "abc" turns into "a".
// Example:
// midChar2("hello") == "ell"
// midChar2("a") == "a"
// midChar2("ab") == "a"
func midChar2(str: String) -> String {
    return str.prefix(1) + str.dropFirst().dropLast().dropFirst().dropLast() + str.last!
}

// Given a string, return a new string with the first char added at the
// beginning, the last char added at the end, and the 2 chars in the middle
// replaced by '$', so "kitten" turns into "kt$it".

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else if b*b + c*c == a*a {
        return true
    } else if c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else if b*b + c*c == a*a {
        return true
    } else if c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || b*b + c*c == a*a || c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || b*b + c*c == a*a || c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else if b*b + c*c == a*a {
        return true
    } else if c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else if b*b + c*c == a*a {
        return true
    } else if c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a) + (b * b) == (c * c)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a) + (b * b) == (c * c)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here.
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here.
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (a * a + b * b == c * c)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (a * a + b * b == c * c)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    return sum == 10
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    return sum == 10
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (s * (s - a) * (s - b) * (s - c) == 0)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (s * (s - a) * (s - b) * (s - c) == 0)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    return sum == 10
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    return sum == 10
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    return sum == 10
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    return sum == 10
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (s * s == (a * a) + (b * b) + (c * c))
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (s * s == (a * a) + (b * b) + (c * c))
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    let isRightAngle = a * a + b * b == c * c
    return isRightAngle
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b + c
    let isRightAngle = a * a + b * b == c * c
    return isRightAngle
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (s * s == (a * a) + (b * b) + (c * c))
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (s * s == (a * a) + (b * b) + (c * c))
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfOtherTwoSides = sortedSides[1] * sortedSides[1] + sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfOtherTwoSides
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfOtherTwoSides = sortedSides[1] * sortedSides[1] + sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfOtherTwoSides
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a, b, c].map { $0 * $0 }
    return squares.contains(90)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a, b, c].map { $0 * $0 }
    return squares.contains(90)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfOtherTwoSides = sortedSides[1] * sortedSides[1] + sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfOtherTwoSides
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfOtherTwoSides = sortedSides[1] * sortedSides[1] + sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfOtherTwoSides
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a, b, c].map { $0 * $0 }
    return squares.contains(90)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a, b, c].map { $0 * $0 }
    return squares.contains(90)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let square = sides.reduce(0, +)
    let squareRoot = Int(sqrt(Double(square)))
    return square == squareRoot * squareRoot
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let square = sides.reduce(0, +)
    let squareRoot = Int(sqrt(Double(square)))
    return square == squareRoot * squareRoot
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b
    let max = max(a, b)
    let min = min(a, b)
    let diff = sum - max - min
    let isRightAngle = diff > 0 && diff <= max
    return isRightAngle
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sum = a + b
    let max = max(a, b)
    let min = min(a, b)
    let diff = sum - max - min
    let isRightAngle = diff > 0 && diff <= max
    return isRightAngle
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    let area = sqrt(s * (s - a) * (s - b) * (s - c))
    return area == Int(area)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let square = a * a + b * b
    let cSquare = c * c
    return square == cSquare
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let square = a * a + b * b
    let cSquare = c * c
    return square == cSquare
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let max = squares.max()!
    let sum = squares.reduce(0, +)
    return max == sum - max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let max = squares.max()!
    let sum = squares.reduce(0, +)
    return max == sum - max
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let sortedSquares = squares.sorted()
    return sortedSquares[2] == sortedSquares[0] + sortedSquares[1]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let sortedSquares = squares.sorted()
    return sortedSquares[2] == sortedSquares[0] + sortedSquares[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let square = [a, b, c].sorted()
    return square[2] * square[2] == square[0] * square[0] + square[1] * square[1]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let square = [a, b, c].sorted()
    return square[2] * square[2] == square[0] * square[0] + square[1] * square[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let sortedSquares = squares.sorted()
    return sortedSquares[2] == sortedSquares[0] + sortedSquares[1]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let sortedSquares = squares.sorted()
    return sortedSquares[2] == sortedSquares[0] + sortedSquares[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let max = squares.max()!
    let sum = squares.reduce(0, +)
    return max == sum - max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let max = squares.max()!
    let sum = squares.reduce(0, +)
    return max == sum - max
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let max = squares.max()!
    let sum = squares.reduce(0, +)
    return max == sum - max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let squares = [a * a, b * b, c * c]
    let max = squares.max()!
    let sum = squares.reduce(0, +)
    return max == sum - max
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let square = a * a + b * b
    let cSquare = c * c
    return square == cSquare
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let square = a * a + b * b
    let cSquare = c * c
    return square == cSquare
}
```

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    
    
    
    guard a = [[Double](

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    return lhs = [[Double]
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    
    
    for i
    

import Foundation

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

```swift
import Foundation

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

/*
 Given the lengths of the three sides of a triangle. Return true if the three
 sides form a right-angled triangle, false otherwise.
 A right-angled triangle is a triangle in which one angle is right angle or 
 90 degree.
 Example:
 rightAngleTriangle(a: 3, b: 4, c: 5) == true
 rightAngleTriangle(a: 1, b: 2, c: 3) == false
 */
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    
    
    
    
    
    
    

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
Here is a right angle is a right angle triangle






```

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
```

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
<|padding|>

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
```

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
```

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
<|padding|>

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
Here is the function implementation



    // First, we need to check for a triangle inequality of Pyth the triangle inequality condition 
    if

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
```

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
Here is a function implementation in Swift function:
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
import Foundation

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    sides.sort()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    sides.sort()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    sides.sort()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    sides.sort()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    sides.sort()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    sides.sort()
    return pow(Double(sides[0]), 2) + pow(Double(sides[1]), 2) == pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return Math.pow(Double(sides[0]), 2) + Math.pow(Double(sides[1]), 2) == Math.pow(Double(sides[2]), 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    
    if a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2 {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: implement me!
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: implement me!
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your implementation here.
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your implementation here.
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Ex

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else {
        return false
    }
}
```
### Challenge

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let hypotenuse = sortedSides[2]
    let leg1 = sortedSides[0]
    let leg2 = sortedSides[1]
    return hypotenuse * hypotenuse == leg1 * leg1 + leg2 * leg2
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let hypotenuse = sortedSides[2]
    let leg1 = sortedSides[0]
    let leg2 = sortedSides[1]
    return hypotenuse * hypotenuse == leg1 * leg1 + leg2 * leg2
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```
### Test

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, max(b, c))
    let minSide = min(a, min(b, c))
    let midSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + midSide * midSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, max(b, c))
    let minSide = min(a, min(b, c))
    let midSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + midSide * midSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let midSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + midSide * midSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let midSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + midSide * midSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - minSide - maxSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - minSide - maxSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let maxSide = sides.max()!
    let minSide = sides.min()!
    let middleSide = sides.filter { $0 != minSide && $0 != maxSide }.first!
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let maxSide = sides.max()!
    let minSide = sides.min()!
    let middleSide = sides.filter { $0 != minSide && $0 != maxSide }.first!
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, max(b, c))
    let minSide = min(a, min(b, c))
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, max(b, c))
    let minSide = min(a, min(b, c))
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let maxSide = max(a, b, c)
    let minSide = min(a, b, c)
    let middleSide = a + b + c - maxSide - minSide
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let maxSide = sides.max()!
    let minSide = sides.min()!
    let middleSide = sides.filter { $0 != maxSide && $0 != minSide }.first!
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let maxSide = sides.max()!
    let minSide = sides.min()!
    let middleSide = sides.filter { $0 != maxSide && $0 != minSide }.first!
    return maxSide * maxSide == minSide * minSide + middleSide * middleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3)) // Expected output: false
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure that 'c' is the longest side.
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of the two shorter sides equals the square of the longest side.
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure that 'c' is the longest side.
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of the two shorter sides equals the square of the longest side.
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3)) // Expected output: false
```

This function takes three integer values representing the lengths of the sides of a triangle and returns a Boolean value indicating whether the sides form a right-angled triangle.

The function first sorts the sides to ensure that 'c' is the longest side. It then checks if the sum of the squares of the two shorter sides equals the square of the longest side, which is the condition for a right-angled triangle.

Note: The function assumes that the input values are positive integers and does not check for the triangle inequality theorem, which states that the sum of the lengths of any two sides of a triangle must be greater than the length of the remaining side.

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the largest side is last.
    let sides = [A, b, c].sorted()
    // Check if the sum of the squares of the two smaller sides equals the square of the largest side.
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the largest side is last.
    let sides = [A, b, c].sorted()
    // Check if the sum of the squares of the two smaller sides equals the square of the largest side.
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5))  // Expected output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3))  // Expected output: false
```

This function uses the Pythagorean theorem to determine if a triangle with sides of length `A`, `b`, and `c` is a right-angled triangle. The theorem states that in a right-angled triangle, the square of the length of the hypotenuse (the side opposite the right angle) is equal to the sum of the squares of the lengths of the other two sides.

In this code, we sort the sides to ensure the largest side is last, and then check if the sum of the squares of the two smaller sides equals the square of the largest side. If this condition is true, it means that the triangle is a right-angled triangle.

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the largest side is considered as the hypotenuse
    let sides = [A, b, c].sorted()
    // Check the Pythagorean theorem: a^2 + b^2 = c^2
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the largest side is considered as the hypotenuse
    let sides = [A, b, c].sorted()
    // Check the Pythagorean theorem: a^2 + b^2 = c^2
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3)) // Expected output: false
```

This function uses the Pythagorean theorem to determine if a triangle with sides of length `A`, `b`, and `c` is a right-angled triangle. The theorem states that in a right-angled triangle, the square of the length of the hypotenuse (the side opposite the right angle) is equal to the sum of the squares of the lengths of the other two sides.

In this function, we first sort the sides to ensure the largest side is considered as the hypotenuse. Then, we check the Pythagorean theorem using the `sorted()` method to ensure the largest side is considered as the hypotenuse.

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure that c is the longest side.
    let sides = [A, b, c].sorted()
    // Check if the square of the longest side is equal to the sum of squares of the other two sides.
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure that c is the longest side.
    let sides = [A, b, c].sorted()
    // Check if the square of the longest side is equal to the sum of squares of the other two sides.
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the largest side is considered as the hypotenuse
    let sides = [A, b, c].sorted()
    // Check the Pythagorean theorem: a^2 + b^2 = c^2
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the largest side is considered as the hypotenuse
    let sides = [A, b, c].sorted()
    // Check the Pythagorean theorem: a^2 + b^2 = c^2
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5)) // Output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3)) // Output: false
```

This function takes three integers representing the lengths of the sides of a triangle and returns a boolean indicating whether it is a right-angled triangle.

The function sorts the sides to ensure the largest side is considered as the hypotenuse. It then checks if the sum of the squares of the two smaller sides equals the square of the largest side, which is the Pythagorean theorem.

Note: The function assumes that the input sides can form a valid triangle.

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to make comparison easier
    let sides = [A, b, c].sorted()
    // Check if the sum of squares of two smaller sides equals the square of the largest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5)) // Output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3)) // Output: false
```

This function uses the Pythagorean theorem to determine if a triangle with sides of length `A`, `b`, and `c` is a right-angled triangle. The theorem states that in a right-angled triangle, the square of the length of the hypotenuse (the side opposite the right angle) is equal to the sum of the squares of the lengths of the other two sides.

In the example usage, the first call with sides of length `3`, `4`, and `5` is a right-angled triangle because `3^2 + 4^2 = 5^2`. The second call with sides of length `1`, `2`, and `3` is not a right-angled triangle because `1^2 + 2^2 != 3^2`.

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure that c is the longest side
    let sides = [A, b, c].sorted()
    
    // Check the Pythagorean theorem: a^2 + b^2 = c^2
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure that c is the longest side
    let sides = [A, b, c].sorted()
    
    // Check the Pythagorean theorem: a^2 + b^2 = c^2
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(A: 3, b: 4, c: 5))  // Expected output: true
print(rightAngleTriangle(A: 1, b: 2, c: 3))  // Expected output: false
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = pow(Double(a), 2)
    let b2 = pow(Double(b), 2)
    let c2 = pow(Double(c), 2)
    return (a2 + b2 == c2) || (a2 + c2 == b2) || (b2 + c2 == a2)
}

func palindrome(str: String) -> Bool {
    let str = str.lowercased()
    let reversed = String(str.reversed())
    return str == reversed
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "a"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "b"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "c"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "d"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "e"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "f"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "g"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "h"}.count
}

func countChar(str: String) -> Int {
    return str.filter{$0 == "i"}.count
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = pow(Double(a), 2)
    let b2 = pow(Double(b), 2)
    let c2 = pow(Double(c), 2)
    return (a2 + b2 == c2) || (a2 + c2 == b2) || (b2 + c2 == a2)
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a string that reads the same forwards and backwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    let str = str.lowercased()
    let reversed = String(str.reversed())
    return str == reversed
}

// Given a string, return the number of times the character 'a' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "a"}.count
}

// Given a string, return the number of times the character 'b' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "b"}.count
}

// Given a string, return the number of times the character 'c' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "c"}.count
}

// Given a string, return the number of times the character 'd' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "d"}.count
}

// Given a string, return the number of times the character 'e' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "e"}.count
}

// Given a string, return the number of times the character 'f' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "f"}.count
}

// Given a string, return the number of times the character 'g' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "g"}.count
}

// Given a string, return the number of times the character 'h' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "h"}.count
}

// Given a string, return the number of times the character 'i' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "i"}.count
}

// Given a string, return the number of times the character 'j' appears in the
// string.
// Example:
// countChar("hello") == 2
// countChar("a") == 1
// countChar("aaaa") == 4
func countChar(str: String) -> Int {
    return str.filter{$0 == "j"}.count

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    return aSquared + bSquared == cSquared || bSquared + cSquared == aSquared || aSquared + cSquared == bSquared
}

func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    return aSquared + bSquared == cSquared || bSquared + cSquared == aSquared || aSquared + cSquared == bSquared
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:
// removeDuplicates("aaa") == ""
// removeDuplicates("aaabbbccc") == "abc"
func removeDuplicates(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        if i == 0 || str[i] != str[i - 1] {
            result += String(str[i])
        }
    }
    return result
}

// Given a string, return the string with all consecutive duplicate characters
// removed.
// Example:

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2
}
<|file_separator|>```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2
}

func sumOfDigits(n: Int) -> Int {
    var sum = 0
    var num = n
    while num > 0 {
        sum += num % 10
        num /= 10
    }
    return sum
}

func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    var sum = 0
    var num = n
    while num > 0 {
        sum += num % 10
        num /= 10
    }
    return sum
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15
func sumOfDigits(n: Int) -> Int {
    return n.digits().reduce(0, +)
}

// Given a number, return the sum of its digits.
// Example:
// sumOfDigits(123) == 6
// sumOfDigits(12345) == 15

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}
<|file_separator|>```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c || b * b + c * c == a * a || c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c || b * b + c * c == a * a || c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a
}

func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("am") == 1
// countAm("am am") == 2
// countAm("am and am") == 2
// countAm("am, am") == 2
func countAm(str: String) -> Int {
    return str.componentsSeparatedByString("am").count - 1
}

// Given a

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c || b * b + c * c == a * a || c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c || b * b + c * c == a * a || c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
<|file_separator|>```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    return aSquared + bSquared == cSquared || aSquared + cSquared == bSquared || bSquared + cSquared == aSquared
}

func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    return aSquared + bSquared == cSquared || aSquared + cSquared == bSquared || bSquared + cSquared == aSquared
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains(char) {
            result += String(char)
        }
    }
    return result
}

// Given a string, return the string with all the vowels removed.
// Example:
// removeVowels("Hello") == "Hll"
// removeVowels("aeiou") == ""
func removeVowels(str: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for char in str {
        if !vowels.contains

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a = a * a
    let b = b * b
    let c = c * c
    
    if a + b == c || a + c == b || b + c == a {
        return true
    }
    return false
}

func countAm(str: String) -> Int {
    let am = "am"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == am {
            count += 1
        }
    }
    return count
}

func countA(str: String) -> Int {
    let a = "a"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == a {
            count += 1
        }
    }
    return count
}

func countAn(str: String) -> Int {
    let an = "an"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == an {
            count += 1
        }
    }
    return count
}

func countThe(str: String) -> Int {
    let the = "the"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == the {
            count += 1
        }
    }
    return count
}

func countAnd(str: String) -> Int {
    let and = "and"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == and {
            count += 1
        }
    }
    return count
}

func countOr(str: String) -> Int {
    let or = "or"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == or {
            count += 1
        }
    }
    return count
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a = a * a
    let b = b * b
    let c = c * c
    
    if a + b == c || a + c == b || b + c == a {
        return true
    }
    return false
}

// Given a string, return the number of times "am" appears in the string.
// Example:
// countAm("I am happy") == 1
// countAm("I am happy am") == 2
func countAm(str: String) -> Int {
    let am = "am"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == am {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "a" appears in the string.
// Example:
// countA("I am happy") == 1
// countA("I am happy am") == 2
func countA(str: String) -> Int {
    let a = "a"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == a {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "an" appears in the string.
// Example:
// countAn("I am happy") == 1
// countAn("I am happy an") == 2
func countAn(str: String) -> Int {
    let an = "an"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == an {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "the" appears in the string.
// Example:
// countThe("I am happy") == 1
// countThe("I am happy the") == 2
func countThe(str: String) -> Int {
    let the = "the"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == the {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "and" appears in the string.
// Example:
// countAnd("I am happy") == 1
// countAnd("I am happy and") == 2
func countAnd(str: String) -> Int {
    let and = "and"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == and {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "or" appears in the string.
// Example:
// countOr("I am happy") == 1
// countOr("I am happy or") == 2
func countOr(str: String) -> Int {
    let or = "or"
    var count = 0
    
    for i in 0..<str.count {
        let sub = str[str.index(str.startIndex, offsetBy: i)..<str.index(str.startIndex, offsetBy: i + 1)]
        if sub == or {
            count += 1
        }
    }
    return count
}

// Given a string, return the number of times "not" appears in the string.
// Example:
// countNot("I am happy") == 1
// countNot("I am happy not") == 2
func countNot(str: String) ->

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    return aSquared + bSquared == cSquared || aSquared + cSquared == bSquared || bSquared + cSquared == aSquared
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    return aSquared + bSquared == cSquared || aSquared + cSquared == bSquared || bSquared + cSquared == aSquared
}
<|file_separator|>```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}

func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

func sumOfArray(array: [Int]) -> Int {
    var sum = 0
    for i in array {
        sum += i
    }
    return sum
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    var sum = 0
    for i in array {
        sum += i
    }
    return sum
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    return array.reduce(0, +)
}

// Given an array of integers, return the sum of the integers.
// Example:
// sumOfArray([1, 2, 3, 4, 5]) == 15
func sumOfArray(array: [Int]) -> Int {
    

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c || b * b + c * c == a * a || c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c || b * b + c * c == a * a || c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
  return a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
  return a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    
    return aSquared + bSquared == cSquared ||
           aSquared + cSquared == bSquared ||
           bSquared + cSquared == aSquared
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    
    return aSquared + bSquared == cSquared ||
           aSquared + cSquared == bSquared ||
           bSquared + cSquared == aSquared
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}
<|file_separator|>```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
        return true
    } else {
        return false
    }
}
<|file_separator|>

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || b*b + c*c == a*a || c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}

func palindrome(str: String) -> Bool {
    var str = str.lowercased()
    var str2 = ""
    for i in str.characters {
        if i != " " {
            str2 += String(i)
        }
    }
    for i in 0..<str2.characters.count/2 {
        if str2[str2.startIndex.advancedBy(i)] != str2[str2.startIndex.advancedBy(str2.characters.count-i-1)] {
            return false
        }
    }
    return true
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c || b*b + c*c == a*a || c*c + a*a == b*b {
        return true
    } else {
        return false
    }
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that reads the same backwards as forwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    var str = str.lowercased()
    var str2 = ""
    for i in str.characters {
        if i != " " {
            str2 += String(i)
        }
    }
    for i in 0..<str2.characters.count/2 {
        if str2[str2.startIndex.advancedBy(i)] != str2[str2.startIndex.advancedBy(str2.characters.count-i-1)] {
            return false
        }
    }
    return true
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that reads the same backwards as forwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    var str = str.lowercased()
    var str2 = ""
    for i in str.characters {
        if i != " " {
            str2 += String(i)
        }
    }
    for i in 0..<str2.characters.count/2 {
        if str2[str2.startIndex.advancedBy(i)] != str2[str2.startIndex.advancedBy(str2.characters.count-i-1)] {
            return false
        }
    }
    return true
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that reads the same backwards as forwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    var str = str.lowercased()
    var str2 = ""
    for i in str.characters {
        if i != " " {
            str2 += String(i)
        }
    }
    for i in 0..<str2.characters.count/2 {
        if str2[str2.startIndex.advancedBy(i)] != str2[str2.startIndex.advancedBy(str2.characters.count-i-1)] {
            return false
        }
    }
    return true
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that reads the same backwards as forwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    var str = str.lowercased()
    var str2 = ""
    for i in str.characters {
        if i != " " {
            str2 += String(i)
        }
    }
    for i in 0..<str2.characters.count/2 {
        if str2[str2.startIndex.advancedBy(i)] != str2[str2.startIndex.advancedBy(str2.characters.count-i-1)] {
            return false
        }
    }
    return true
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome is a word or phrase that reads the same backwards as forwards.
// Example:
// palindrome("racecar") == true
// palindrome("hello") == false
func palindrome(str: String) -> Bool {
    var str = str.lowercased()
    var str2 = ""
    for i in str.characters {
        if i != " " {
            str2 += String(i)
        }
    }
    for i in 0..<str2.characters.count/2 {
        if str2[str2.startIndex.advancedBy(i)] != str2[str2.startIndex.advancedBy(str2.characters.count-i-1)] {
            return false
        }
    }
    return true
}

// Given a string, return true if the string is a palindrome, false otherwise.
// A palindrome

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a = a * a
    let b = b * b
    let c = c * c
    
    if a + b == c || a + c == b || b + c == a {
        return true
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a = a * a
    let b = b * b
    let c = c * c
    
    if a + b == c || a + c == b || b + c == a {
        return true
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSqr = a * a
    let bSqr = b * b
    let cSqr = c * c
    
    if (aSqr + bSqr == cSqr) {
        return true
    }
    
    if (aSqr + cSqr == bSqr) {
        return true
    }
    
    if (bSqr + cSqr == aSqr) {
        return true
    }
    
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSqr = a * a
    let bSqr = b * b
    let cSqr = c * c
    
    if (aSqr + bSqr == cSqr) {
        return true
    }
    
    if (aSqr + cSqr == bSqr) {
        return true
    }
    
    if (bSqr + cSqr == aSqr) {
        return true
    }
    
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    
    if aSquared + bSquared == cSquared || aSquared + cSquared == bSquared || bSquared + cSquared == aSquared {
        return true
    }
    
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    
    if aSquared + bSquared == cSquared || aSquared + cSquared == bSquared || bSquared + cSquared == aSquared {
        return true
    }
    
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    
    if aSquared + bSquared == cSquared {
        return true
    } else if bSquared + cSquared == aSquared {
        return true
    } else if aSquared + cSquared == bSquared {
        return true
    } else {
        return false
    }
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let aSquared = a * a
    let bSquared = b * b
    let cSquared = c * c
    
    if aSquared + bSquared == cSquared {
        return true
    } else if bSquared + cSquared == aSquared {
        return true
    } else if aSquared + cSquared == bSquared {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    let sum = a2 + b2
    return sum == c2
}

func fizzBuzz(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        let subStr = str[i..<i+3]
        if subStr == "fizz" {
            result += "buzz"
        } else if subStr == "buzz" {
            result += "fizz"
        } else {
            result += subStr
        }
    }
    return result
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    let sum = a2 + b2
    return sum == c2
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz" and every occurrence of the string "buzz" with "fizz".
// Example:
// fizzBuzz("fizz") == "buzz"
// fizzBuzz("buzz") == "fizz"
// fizzBuzz("fizzbuzz") == "fizzfizzbuzzbuzzbuzz"
func fizzBuzz(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        let subStr = str[i..<i+3]
        if subStr == "fizz" {
            result += "buzz"
        } else if subStr == "buzz" {
            result += "fizz"
        } else {
            result += subStr
        }
    }
    return result
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz" and every occurrence of the string "buzz" with "fizz".
// Example:
// fizzBuzz("fizz") == "buzz"
// fizzBuzz("buzz") == "fizz"
// fizzBuzz("fizzbuzz") == "fizzfizzbuzzbuzzbuzz"
func fizzBuzz(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        let subStr = str[i..<i+3]
        if subStr == "fizz" {
            result += "buzz"
        } else if subStr == "buzz" {
            result += "fizz"
        } else {
            result += subStr
        }
    }
    return result
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz" and every occurrence of the string "buzz" with "fizz".
// Example:
// fizzBuzz("fizz") == "buzz"
// fizzBuzz("buzz") == "fizz"
// fizzBuzz("fizzbuzz") == "fizzfizzbuzzbuzzbuzz"
func fizzBuzz(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        let subStr = str[i..<i+3]
        if subStr == "fizz" {
            result += "buzz"
        } else if subStr == "buzz" {
            result += "fizz"
        } else {
            result += subStr
        }
    }
    return result
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz" and every occurrence of the string "buzz" with "fizz".
// Example:
// fizzBuzz("fizz") == "buzz"
// fizzBuzz("buzz") == "fizz"
// fizzBuzz("fizzbuzz") == "fizzfizzbuzzbuzzbuzz"
func fizzBuzz(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        let subStr = str[i..<i+3]
        if subStr == "fizz" {
            result += "buzz"
        } else if subStr == "buzz" {
            result += "fizz"
        } else {
            result += subStr
        }
    }
    return result
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz" and every occurrence of the string "buzz" with "fizz".
// Example:
// fizzBuzz("fizz") == "buzz"
// fizzBuzz("buzz") == "fizz"
// fizzBuzz("fizzbuzz") == "fizzfizzbuzzbuzzbuzz"
func fizzBuzz(str: String) -> String {
    var result = ""
    for i in 0..<str.count {
        let subStr = str[i..<i+3]
        if subStr == "fizz" {
            result += "buzz"
        } else if subStr == "buzz" {
            result += "fizz"
        } else {
            result += subStr
        }
    }
    return result
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz" and every occurrence of the string "buzz" with "fizz".
// Example:
// fizzBuzz("fizz") == "buzz"
// fizzBuzz

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    let sum = a2 + b2
    return sum == c2
}

func fizzBuzz(s: String) -> String {
    let mut result = ""
    for i in 0..<s.length {
        let substr = s.substring(i, i + 4)
        if substr == "fizz" {
            result += "buzz"
        } else if substr == "buzz" {
            result += "fizz"
        } else if substr == "fizzbuzz" {
            result += "fizzbuzz"
        } else {
            result += substr
        }
    }
    return result
}

func reverse(s: String) -> String {
    let mut result = ""
    for i in (0..<s.length).rev {
        result += s[i]
    }
    return result
}

func swap(s: String) -> String {
    if s.length < 2 {
        return s
    }
    let first = s[0..<2]
    let last = s[2..<s.length]
    return last + first
}

func firstUniqueSubstring(s: String) -> Int {
    let mut map = Map<Char, Int>()
    for (i, c) in s.chars().enumerate() {
        let count = map.get(&c).unwrap_or(0)
        map.insert(c, count + 1)
    }
    for (i, c) in s.chars().enumerate() {
        if map.get(&c).unwrap() == 1 {
            return i + 1
        }
    }
    return 0
}

func longestSubstring(s: String) -> Int {
    let mut map = Map<Char, Int>()
    let mut max = 0
    let mut start = 0
    for (i, c) in s.chars().enumerate() {
        if map.contains_key(&c) {
            start = map.get(&c).unwrap() + 1
        }
        map.insert(c, i)
        max = max.max(i - start + 1)
    }
    return max
}

func countBob(s: String) -> Int {
    let mut count = 0
    for i in 0..<s.length - 2 {
        if s[i] == 'b' && s[i + 1] == 'o' && s[i + 2] == 'b' {
            count += 1
        }
    }
    return count
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    let sum = a2 + b2
    return sum == c2
}

// Given a string, return a new string that replaces every occurrence of the
// string "fizz" with "buzz", every occurrence of the string "buzz" with "fizz",
// and every occurrence of the string "fizzbuzz" with "fizzbuzz".
// Example:
// fizzBuzz("fizzbuzz") == "fizzbuzz"
// fizzBuzz("fizz") == "buzz"
// fizzBuzz("buzz") == "fizz"
func fizzBuzz(s: String) -> String {
    let mut result = ""
    for i in 0..<s.length {
        let substr = s.substring(i, i + 4)
        if substr == "fizz" {
            result += "buzz"
        } else if substr == "buzz" {
            result += "fizz"
        } else if substr == "fizzbuzz" {
            result += "fizzbuzz"
        } else {
            result += substr
        }
    }
    return result
}

// Given a string, return the string with its characters in reverse order.
// Example:
// reverse("apple") == "elppa"
// reverse("a") == "a"
// reverse("ab") == "ba"
func reverse(s: String) -> String {
    let mut result = ""
    for i in (0..<s.length).rev {
        result += s[i]
    }
    return result
}

// Given a string, return a new string with the first 2 characters swapped.
// If the string is shorter than 2 characters, leave the extra characters as is.
// Example:
// swap("code") == "code"
// swap("ab") == "ba"
// swap("a") == "a"
func swap(s: String) -> String {
    if s.length < 2 {
        return s
    }
    let first = s[0..<2]
    let last = s[2..<s.length]
    return last + first
}

// Given a string, return the length of the first substring that contains only
// one unique character. If the string does not contain any unique characters,
// return 0.
// Example:
// firstUniqueSubstring("abcabc") == 3
// firstUniqueSubstring("abc") == 1
// firstUniqueSubstring("aabbcc") == 0
func firstUniqueSubstring(s: String) -> Int {
    let mut map = Map<Char, Int>()
    for (i, c) in s.chars().enumerate() {
        let count = map.get(&c).unwrap_or(0)
        map.insert(c, count + 1)
    }
    for (i, c) in s.chars().enumerate() {
        if map.get(&c).unwrap() == 1 {
            return i + 1
        }
    }
    return 0
}

// Given a string, return the length of the longest substring without repeating
// characters.
// Example:
// longestSubstring("abcabcbb") == 3
// longestSubstring("bbbbb") == 1
// longestSubstring("pwwkew") == 3
func longestSubstring(s: String) -> Int {
    let mut map = Map<Char, Int>()
    let mut max = 0
    let mut start = 0
    for (i, c) in s.chars().enumerate() {
        if map.contains_key(&c) {
            start = map.get(&c).unwrap() + 1
        }
        map.insert(c, i)
        max = max.max(i - start + 1)
    }
    return max
}

// Given a string, return the number of times the string "bob" occurs in the
// string.
// Example:
// countBob("abob") == 1
// countBob("bobob") == 2
// countBob("b") == 0
func countBob(s: String) -> Int {
    let mut count = 0
    for i in 0..<s.length - 2 {
        if s[i] == 'b' && s[i + 1] == 'o' && s[i + 2] == 'b' {
            count += 1
        }
    }
    return count
}

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of integers, return a new array with each value doubled.
// Example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(array: [Int]) -> [Int] {
    var doubledArray: [Int] = []
    for i in 0..<array.count {
        doubledArray.append(array[i] * 2)
    }
    return doubledArray
}
// Given an array of

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

func sumOfList(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        sum += i
    }
    return sum
}

func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
// Given a list of integers, return the sum of the first value in the list, plus the
// list length.
// Example:
// sumOfList([1, 2, 3]) == 4
// sumOfList([92, 3, 4, 2, 9]) == 102
func sumOfList(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        sum += i
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only.
// Example:
// sumOfEven([1, 2, 3, 4, 5, 6]) == 12
// sumOfEven([1, 3, 5]) == 0
func sumOfEven(list: [Int]) -> Int {
    var sum = 0
    for i in list {
        if i % 2 == 0 {
            sum += i
        }
    }
    return sum
}
// Given a list of integers, return the sum of the even integers only

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return (a2 + b2 == c2) || (b2 + c2 == a2) || (a2 + c2 == b2)
}

func doubleArray(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray2(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray3(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray4(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray5(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray6(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray7(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray8(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray9(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return (a2 + b2 == c2) || (b2 + c2 == a2) || (a2 + c2 == b2)
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray2(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray3(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray4(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray5(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray6(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray7(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray8(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray9(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray10(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let cSquared = c * c
    let bSquared = b * b
    let aSquared = a * a
    let sumOfSquares = cSquared + bSquared
    return sumOfSquares == aSquared
}

func removeFirstLast(str: String) -> String {
    let length = str.length
    if length == 0 {
        return ""
    }
    let firstChar = str[0]
    let lastChar = str[length - 1]
    let middleChars = str[1:length - 1]
    return middleChars.stringByAddingCharacters(firstChar, lastChar)
}

func swapFirstAndLast(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstChar = str[0]
    let lastChar = str[length - 1]
    let middleChars = str[1:length - 1]
    return lastChar + middleChars + firstChar
}

func appendMore(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstTwoChars = str[0:2]
    let restOfString = str[2:]
    return restOfString + firstTwoChars
}

func prependMore(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstTwoChars = str[0:2]
    let restOfString = str[2:]
    return firstTwoChars + restOfString
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let cSquared = c * c
    let bSquared = b * b
    let aSquared = a * a
    let sumOfSquares = cSquared + bSquared
    return sumOfSquares == aSquared
}

// Given a string, return a new string with the first and last characters
// removed.
// Example:
// removeFirstLast("code") == "ode"
// removeFirstLast("app") == "pp"
// removeFirstLast("coding") == "odin"
func removeFirstLast(str: String) -> String {
    let length = str.length
    if length == 0 {
        return ""
    }
    let firstChar = str[0]
    let lastChar = str[length - 1]
    let middleChars = str[1:length - 1]
    return middleChars.stringByAddingCharacters(firstChar, lastChar)
}

// Given a string, return a new string with the first 2 characters swapped.
// If the string length is less than 2, return the empty string.
// Example:
// swapFirstAndLast("code") == "eodc"
// swapFirstAndLast("a") == "a"
// swapFirstAndLast("h") == "h"
func swapFirstAndLast(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstChar = str[0]
    let lastChar = str[length - 1]
    let middleChars = str[1:length - 1]
    return lastChar + middleChars + firstChar
}

// Given a string, return a new string where the first 2 chars have been
// appended to the end. If the string length is less than 2, return the empty
// string.
// Example:
// appendMore("code") == "odecode"
// appendMore("a") == "a"
// appendMore("h") == "h"
func appendMore(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstTwoChars = str[0:2]
    let restOfString = str[2:]
    return restOfString + firstTwoChars
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2, return the empty
// string.
// Example:
// prependMore("code") == "codecode"
// prependMore("a") == "a"
// prependMore("h") == "h"
func prependMore(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstTwoChars = str[0:2]
    let restOfString = str[2:]
    return firstTwoChars + restOfString
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2, return the empty
// string.
// Example:
// prependMore("code") == "codecode"
// prependMore("a") == "a"
// prependMore("h") == "h"
func prependMore(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstTwoChars = str[0:2]
    let restOfString = str[2:]
    return firstTwoChars + restOfString
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2, return the empty
// string.
// Example:
// prependMore("code") == "codecode"
// prependMore("a") == "a"
// prependMore("h") == "h"
func prependMore(str: String) -> String {
    let length = str.length
    if length < 2 {
        return ""
    }
    let firstTwoChars = str[0:2]
    let restOfString = str[2:]
    return firstTwoChars + restOfString
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return (a2 + b2 == c2) || (a2 + c2 == b2) || (b2 + c2 == a2)
}

func removeFirstLast(str: String) -> String {
    let len = str.length
    if len == 0 {
        return ""
    }
    if len == 1 {
        return str
    }
    return str[1..len - 1]
}

func swapFirstTwo(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str[2..len] + str[0..1]
}

func mixUp(a: String, b: String) -> String {
    let aLen = a.length
    let bLen = b.length
    if aLen < 2 || bLen < 2 {
        return a + " " + b
    }
    let aFirst = a[0..1]
    let aSecond = a[2..aLen]
    let bFirst = b[0..1]
    let bSecond = b[2..bLen]
    return bFirst + aSecond + " " + aFirst + bSecond
}

func appendMore(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str + str[0..1]
}

func prependMore(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str[len - 1..len] + str[0..len - 2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return (a2 + b2 == c2) || (a2 + c2 == b2) || (b2 + c2 == a2)
}

// Given a string, return a new string with the first and last characters removed.
// Example:
// removeFirstLast("code") == "ode"
// removeFirstLast("app") == "pp"
// removeFirstLast("coding") == "odin"
func removeFirstLast(str: String) -> String {
    let len = str.length
    if len == 0 {
        return ""
    }
    if len == 1 {
        return str
    }
    return str[1..len - 1]
}

// Given a string, return a new string with the first 2 characters swapped.
// Example:
// swapFirstTwo("code") == "coede"
// swapFirstTwo("a") == "a"
// swapFirstTwo("h") == "h"
func swapFirstTwo(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str[2..len] + str[0..1]
}

// Given a string, return a new string with the first 2 characters swapped,
// except the first 2 chars will be the same.
// Example:
// mixUp("dog", "dinner") == "dig donner"
// mixUp("gnash", "sport") == "spash gnort"
// mixUp("pezzy", "firm") == "fizzy perm"
func mixUp(a: String, b: String) -> String {
    let aLen = a.length
    let bLen = b.length
    if aLen < 2 || bLen < 2 {
        return a + " " + b
    }
    let aFirst = a[0..1]
    let aSecond = a[2..aLen]
    let bFirst = b[0..1]
    let bSecond = b[2..bLen]
    return bFirst + aSecond + " " + aFirst + bSecond
}

// Given a string, return a new string where the first 2 chars have been
// appended to the end. If the string length is less than 2, return the string
// unchanged.
// Example:
// appendMore("Hello") == "HelloHello"
// appendMore("ab") == "abab"
// appendMore("H") == "H"
func appendMore(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str + str[0..1]
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2, return the string
// unchanged.
// Example:
// prependMore("Hello") == "HelloHello"
// prependMore("ab") == "abab"
// prependMore("H") == "H"
func prependMore(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str[len - 1..len] + str[0..len - 2]
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2, return the string
// unchanged.
// Example:
// prependMore("Hello") == "HelloHello"
// prependMore("ab") == "abab"
// prependMore("H") == "H"
func prependMore(str: String) -> String {
    let len = str.length
    if len < 2 {
        return str
    }
    return str[len - 1..len] + str[0..len - 2]
}

// Given a string, return a new string where the first 2 chars have been
// prepended to the end. If the string length is less than 2, return the string
// unchanged.
// Example:
// prependMore("Hello") == "HelloHello"
// prependMore("ab") == "abab"
// prependMore("H") == "H"
func prependMore(str: String

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return (a2 + b2 == c2) || (b2 + c2 == a2) || (a2 + c2 == b2)
}

func doubleArray(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray2(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray3(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray4(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray5(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray6(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray7(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray8(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

func doubleArray9(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let a2 = a * a
    let b2 = b * b
    let c2 = c * c
    return (a2 + b2 == c2) || (b2 + c2 == a2) || (a2 + c2 == b2)
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray2(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray3(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray4(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray5(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray6(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray7(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray8(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray9(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2)
    }
    return newArr
}

// Given an array of integers, return a new array with each value doubled.
// For example:
// doubleArray([1, 2, 3]) == [2, 4, 6]
func doubleArray10(arr: [Int]) -> [Int] {
    var newArr = [Int]()
    for i in arr {
        newArr.append(i * 2

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let cSquared = c * c
    let bSquared = b * b
    let aSquared = a * a
    let sumOfSquares = cSquared + bSquared
    return sumOfSquares == aSquared
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let cSquared = c * c
    let bSquared = b * b
    let aSquared = a * a
    let sumOfSquares = cSquared + bSquared
    return sumOfSquares == aSquared
}
// Test
print(rightAngleTriangle(a: 3, b: 4, c: 5)) // true
print(rightAngleTriangle(a: 1, b: 2, c: 3)) // false
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let largestSide = sides.max()!
    
    let squaredLargestSide = largestSide * largestSide
    let sumOfSmallerSidesSquared = (sides.filter { $0 != largestSide }).reduce(0, +) * +
    
    return squaredLargestSide == sumOfSmallerSidesSquared
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let largestSide = sides.max()!
    
    let squaredLargestSide = largestSide * largestSide
    let sumOfSmallerSidesSquared = (sides.filter { $0 != largestSide }).reduce(0, +) * +
    
    return squaredLargestSide == sumOfSmallerSidesSquared
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (a*a + c*c == b*b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (a*a + c*c == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (a*a + c*c == b*b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (a*a + c*c == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a * a + b * b == c * c {
        return true
    } else if b * b + c * c == a * a {
        return true
    } else if c * c + a * a == b * b {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let hypotenuseSquared = Double(c) * Double(c)
    let legASquared = Double(a) * Double(a)
    let legBSquared = Double(b) * Double(b)
    return hypotenuseSquared == legASquared + legBSquared
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let hypotenuseSquared = Double(c) * Double(c)
    let legASquared = Double(a) * Double(a)
    let legBSquared = Double(b) * Double(b)
    return hypotenuseSquared == legASquared + legBSquared
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (a*a + c*c == b*b) || (b*b + c*c == a*a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let hypotenuse = sides.max()!
    let otherSides = sides.filter { $0 != hypotenuse }
    return otherSides.reduce(0, +) * otherSides.reduce(0, +) == hypotenuse * hypotenuse
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let hypotenuse = sides.max()!
    let otherSides = sides.filter { $0 != hypotenuse }
    return otherSides.reduce(0, +) * otherSides.reduce(0, +) == hypotenuse * hypotenuse
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[2] * sides[2] == sides[0] * sides[0] + sides[1] * sides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let hypotenuse = sides.max()!
    let otherSides = sides.filter { $0 != hypotenuse }
    return hypotenuse * hypotenuse == otherSides.reduce(0, +) * otherSides.reduce(0, +)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let hypotenuse = sides.max()!
    let otherSides = sides.filter { $0 != hypotenuse }
    return hypotenuse * hypotenuse == otherSides.reduce(0, +) * otherSides.reduce(0, +)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let hypotenuse = sides.max()!
    let otherSides = sides.filter { $0 != hypotenuse }
    return otherSides.reduce(0, +) * otherSides.reduce(0, +) == hypotenuse * hypotenuse
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<end_of_turn>
<start_of_turn>model
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let hypotenuse = sides.max()!
    let otherSides = sides.filter { $0 != hypotenuse }
    return otherSides.reduce(0, +) * otherSides.reduce(0, +) == hypotenuse * hypotenuse
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a*a + b*b == c*c {
        return true
    } else {
        return false
    }
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (b * b + c * c == a * a) || (c * c + a * a == b * b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a*a + b*b == c*c) || (b*b + c*c == a*a) || (c*c + a*a == b*b)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSum = angles.reduce(0, +)
    return anglesSum == 180
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSum = angles.reduce(0, +)
    return anglesSum == 180
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let rightAngle = 90
    return angles.contains(rightAngle)
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let rightAngle = 90
    return angles.contains(rightAngle)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let angleSum = angles.reduce(0, +)
    return angleSum == 180
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let angleSum = angles.reduce(0, +)
    return angleSum == 180
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSum = angles.reduce(0, +)
    return anglesSum == 180
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSum = angles.reduce(0, +)
    return anglesSum == 180
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c].sorted()
    return angles[0] * angles[0] + angles[1] * angles[1] == angles[2] * angles[2]
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c].sorted()
    return angles[0] * angles[0] + angles[1] * angles[1] == angles[2] * angles[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSet = Set(angles)
    return anglesSet.count == 2
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSet = Set(angles)
    return anglesSet.count == 2
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let angleSquared = angles.map { $0 * $0 }
    let sumOfSquares = angleSquared.reduce(0, +)
    return sumOfSquares == 100
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let angleSquared = angles.map { $0 * $0 }
    let sumOfSquares = angleSquared.reduce(0, +)
    return sumOfSquares == 100
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSum = angles.reduce(0, +)
    return anglesSum == 180
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angles = [a, b, c]
    let anglesSum = angles.reduce(0, +)
    return anglesSum == 180
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angleA = acos((b * b + c * c - a * a) / (2 * b * c))
    let angleB = acos((a * a + c * c - b * b) / (2 * a * c))
    let angleC = acos((a * a + b * b - c * c) / (2 * a * b))
    return angleA == 90 || angleB == 90 || angleC == 90
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angleA = acos((b * b + c * c - a * a) / (2 * b * c))
    let angleB = acos((a * a + c * c - b * b) / (2 * a * c))
    let angleC = acos((a * a + b * b - c * c) / (2 * a * b))
    return angleA == 90 || angleB == 90 || angleC == 90
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angleA = acos((b * b + c * c - a * a) / (2 * b * c))
    let angleB = acos((a * a + c * c - b * b) / (2 * a * c))
    let angleC = acos((a * a + b * b - c * c) / (2 * a * b))
    return angleA == 90 || angleB == 90 || angleC == 90
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false [/INST] ```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let angleA = acos((b * b + c * c - a * a) / (2 * b * c))
    let angleB = acos((a * a + c * c - b * b) / (2 * a * c))
    let angleC = acos((a * a + b * b - c * c) / (2 * a * b))
    return angleA == 90 || angleB == 90 || angleC == 90
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (a * a + b * b == c * c)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return (s > a && s > b && s > c) && (a * a + b * b == c * c)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let s = (a + b + c) / 2
    return s * (s - a) * (s - b) * (s - c) == 0
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfShortestSide = sortedSides[1] * sortedSides[1]
    let squareOfLongestSide = sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfShortestSide + squareOfLongestSide
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfShortestSide = sortedSides[1] * sortedSides[1]
    let squareOfLongestSide = sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfShortestSide + squareOfLongestSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfOtherTwoSides = sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfOtherTwoSides
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfOtherTwoSides = sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfOtherTwoSides
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfShortestSide = sortedSides[0] * sortedSides[0]
    let squareOfMiddleSide = sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfShortestSide + squareOfMiddleSide
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfShortestSide = sortedSides[0] * sortedSides[0]
    let squareOfMiddleSide = sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfShortestSide + squareOfMiddleSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfShortestSide = sortedSides[1] * sortedSides[1]
    let squareOfLongestSide = sortedSides[2] * sortedSides[2]
    
    return squareOfShortestSide + squareOfLongestSide == squareOfHypotenuse
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfShortestSide = sortedSides[1] * sortedSides[1]
    let squareOfLongestSide = sortedSides[2] * sortedSides[2]
    
    return squareOfShortestSide + squareOfLongestSide == squareOfHypotenuse
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfShortestSide = sortedSides[0] * sortedSides[0]
    let squareOfMiddleSide = sortedSides[1] * sortedSides[1]
    return squareOfShortestSide + squareOfMiddleSide == squareOfHypotenuse
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfShortestSide = sortedSides[0] * sortedSides[0]
    let squareOfMiddleSide = sortedSides[1] * sortedSides[1]
    return squareOfShortestSide + squareOfMiddleSide == squareOfHypotenuse
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfOtherTwoSides = sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfOtherTwoSides
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfOtherTwoSides = sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfOtherTwoSides
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfShortestSide = sortedSides[1] * sortedSides[1]
    let squareOfLongestSide = sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfShortestSide + squareOfLongestSide
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[0] * sortedSides[0]
    let squareOfShortestSide = sortedSides[1] * sortedSides[1]
    let squareOfLongestSide = sortedSides[2] * sortedSides[2]
    return squareOfHypotenuse == squareOfShortestSide + squareOfLongestSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfSmallestSide = sortedSides[0] * sortedSides[0]
    let squareOfLargestSide = sortedSides[2] * sortedSides[2]
    return squareOfSmallestSide + squareOfLargestSide == squareOfLargestSide
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfSmallestSide = sortedSides[0] * sortedSides[0]
    let squareOfLargestSide = sortedSides[2] * sortedSides[2]
    return squareOfSmallestSide + squareOfLargestSide == squareOfLargestSide
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfOtherTwoSides = sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfOtherTwoSides
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false

Answer:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    let squareOfHypotenuse = sortedSides[2] * sortedSides[2]
    let squareOfOtherTwoSides = sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
    return squareOfHypotenuse == squareOfOtherTwoSides
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[0], 2) + pow(sides[1], 2) == pow(sides[2], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == pow(sides[0], 2) + pow(sides[1], 2)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return pow(sides[2], 2) == (pow(sides[0], 2) + pow(sides[1], 2))
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false
### Response:
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c].sorted()
    return sides[0]*sides[0] + sides[1]*sides[1] == sides[2]*sides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here.
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here.
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    return sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1] == sortedSides[2] * sortedSides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    return sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1] == sortedSides[2] * sortedSides[2]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a > 0 && b > 0 && c > 0 {
        if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
            return true
        }
    }
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    if a > 0 && b > 0 && c > 0 {
        if a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a {
            return true
        }
    }
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c || a*a + c*c == b*b || b*b + c*c == a*a
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return (a * a + b * b == c * c) || (a * a + c * c == b * b) || (b * b + c * c == a * a)
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Write your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement this function
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement me!
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // TODO: Implement me!
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your implementation goes here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your implementation goes here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a*a + b*b == c*c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    return a * a + b * b == c * c
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2] * sortedSides[2] == sortedSides[0] * sortedSides[0] + sortedSides[1] * sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[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.
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or 
90 degree.
Example:
rightAngleTriangle(a: 3, b: 4, c: 5) == true
rightAngleTriangle(a: 1, b: 2, c: 3) == false<|im_end|>
<|im_start|>assistant
```swift
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    let sides = [a, b, c]
    let sortedSides = sides.sorted()
    
    // Check if the square of the longest side is equal to the sum of the squares of the other two sides
    return sortedSides[2]*sortedSides[2] == sortedSides[0]*sortedSides[0] + sortedSides[1]*sortedSides[1]
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
    return false
}

// Test cases
print(rightAngleTriangle(a: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(a: 1, b: 2, c: 3)) // Expected output: false
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the longest side is last
    let sides = [a, b, c].sorted()
    
    // Check if the sum of the squares of the two shorter sides equals the square of the longest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the longest side is last
    let sides = [a, b, c].sorted()
    
    // Check if the sum of the squares of the two shorter sides equals the square of the longest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(a: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(a: 1, b: 2, c: 3)) // Expected output: false
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
    return false
}
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
    return false
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Your code here
    return false
}

// Test cases
print(rightAngleTriangle(a: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(a: 1, b: 2, c: 3)) // Expected output: false
```

func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the longest side is last
    let sides = [a, b, c].sorted()
    
    // Check if the sum of the squares of the two shorter sides equals the square of the longest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

```swift
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or 
// 90 degree.
// Example:
// rightAngleTriangle(a: 3, b: 4, c: 5) == true
// rightAngleTriangle(a: 1, b: 2, c: 3) == false
func rightAngleTriangle(a: Int, b: Int, c: Int) -> Bool {
    // Sort the sides to ensure the longest side is last
    let sides = [a, b, c].sorted()
    
    // Check if the sum of the squares of the two shorter sides equals the square of the longest side
    return sides[0] * sides[0] + sides[1] * sides[1] == sides[2] * sides[2]
}

// Example usage:
print(rightAngleTriangle(a: 3, b: 4, c: 5)) // Expected output: true
print(rightAngleTriangle(a: 1, b: 2, c: 3)) // Expected output: false
```