Merge pull request kodecocodes#328 from lostatseajoshua/bug-fix-palindromes

Bug fix palindromes

Author: kelvinlauKL

.travis.yml

@@ -41,3 +41,4 @@ script:
 - xcodebuild test -project ./Stack/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Topological\ Sort/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Treap/Treap/Treap.xcodeproj -scheme Tests
+- xcodebuild test -project ./Palindromes/Test/Test.xcodeproj -scheme Test

Palindromes/Palindromes.playground/Contents.swift

@@ -1,34 +1,61 @@
-import Cocoa
+//: Playground - noun: a place where people can play
 
-public func palindromeCheck(text: String?) -> Bool {
-  if let text = text {
-    let mutableText = text.trimmingCharacters(in: NSCharacterSet.whitespaces).lowercased()
-    let length: Int = mutableText.characters.count
+import Foundation
+
+/**
+ Validate that a string is a plaindrome
+ - parameter str: The string to validate
+ - returns: `true` if string is plaindrome, `false` if string is not
+ */
+func isPalindrome(_ str: String) -> Bool {
+    let strippedString = str.replacingOccurrences(of: "\\W", with: "", options: .regularExpression, range: nil)
+    let length = strippedString.characters.count
 
-    if length == 1 || length == 0 {
-      return true
-    } else if mutableText[mutableText.startIndex] == mutableText[mutableText.index(mutableText.endIndex, offsetBy: -1)] {
-      let range = Range<String.Index>(mutableText.index(mutableText.startIndex, offsetBy: 1)..<mutableText.index(mutableText.endIndex, offsetBy: -1))
-      return palindromeCheck(text: mutableText.substring(with: range))
+    if length > 1 {
+        return palindrome(strippedString.lowercased(), left: 0, right: length - 1)
     }
-  }
-  
-  return false
+    return false
 }
 
-// Test to check that non-palindromes are handled correctly:
-palindromeCheck(text: "owls")
-
-// Test to check that palindromes are accurately found (regardless of case and whitespace:
-palindromeCheck(text: "lol")
-palindromeCheck(text: "race car")
-palindromeCheck(text: "Race fast Safe car")
-
-// Test to check that palindromes are found regardless of case:
-palindromeCheck(text: "HelloLLEH")
+/**
+ Compares a strings left side character against right side character following
+ - parameter str: The string to compare characters of
+ - parameter left: Index of left side to compare, must be less than or equal to right
+ - parameter right: Index of right side to compare, must be greater than or equal to left
+ - returns: `true` if left side and right side have all been compared and they all match, `false` if a left and right aren't equal
+ */
+private func palindrome(_ str: String, left: Int, right: Int) -> Bool {
+    if left >= right {
+        return true
+    }
+    
+    let lhs = str[str.index(str.startIndex, offsetBy: left)]
+    let rhs = str[str.index(str.startIndex, offsetBy: right)]
+    
+    if lhs != rhs {
+        return false
+    }
+    
+    return palindrome(str, left: left + 1, right: right - 1)
+}
 
-palindromeCheck(text: "moom")
+//true
+isPalindrome("A man, a plan, a canal, Panama!")
+isPalindrome("abbcbba")
+isPalindrome("racecar")
+isPalindrome("Madam, I'm Adam")
+isPalindrome("Madam in Eden, I'm Adam")
+isPalindrome("Never odd or even")
+isPalindrome("5885")
+isPalindrome("5 8 8 5")
+isPalindrome("58 85")
+isPalindrome("৯৯")
+isPalindrome("In girum imus nocte et consumimur igni")
 
-// Test that nil and empty Strings return false:
-palindromeCheck(text: "")
-palindromeCheck(text: nil)
+// false
+isPalindrome("\\\\")
+isPalindrome("desserts")
+isPalindrome("😀😀")
+isPalindrome("")
+isPalindrome("a")
+isPalindrome("power")

Palindromes/Palindromes.swift

@@ -1,17 +1,26 @@
-import Cocoa
+import Foundation
 
-public func palindromeCheck(text: String?) -> Bool {
-  if let text = text {
-    let mutableText = text.trimmingCharacters(in: NSCharacterSet.whitespaces).lowercased()
-    let length: Int = mutableText.characters.count
+func isPalindrome(_ str: String) -> Bool {
+    let strippedString = str.replacingOccurrences(of: "\\W", with: "", options: .regularExpression, range: nil)
+    let length = strippedString.characters.count
 
-    if length == 1 || length == 0 {
-      return true
-    } else if mutableText[mutableText.startIndex] == mutableText[mutableText.index(mutableText.endIndex, offsetBy: -1)] {
-      let range = Range<String.Index>(mutableText.index(mutableText.startIndex, offsetBy: 1)..<mutableText.index(mutableText.endIndex, offsetBy: -1))
-      return palindromeCheck(text: mutableText.substring(with: range))
+    if length > 1 {
+        return palindrome(strippedString.lowercased(), left: 0, right: length - 1)
     }
-  }
-  
-  return false
+    return false
+}
+
+private func palindrome(_ str: String, left: Int, right: Int) -> Bool {
+    if left >= right {
+        return true
+    }
+    
+    let lhs = str[str.index(str.startIndex, offsetBy: left)]
+    let rhs = str[str.index(str.startIndex, offsetBy: right)]
+    
+    if lhs != rhs {
+        return false
+    }
+    
+    return palindrome(str, left: left + 1, right: right - 1)
 }

Palindromes/README.markdown

@@ -1,64 +1,107 @@
 # Palindromes
 
-A palindrome is a word or phrase that is spelled the exact same when read forwards or backwards. 
-For this example puzzle, palindromes will not take case into account, meaning that uppercase and
-lowercase text will be treated the same. In addition, spaces will not be considered, allowing 
-for multi-word phrases to constitute palindromes too. 
+A palindrome is a word or phrase that is spelled the exact same when reading it forwards or backward. Palindromes are allowed to be lowercase or uppercase, contain spaces, punctuation, and word dividers.
 
 Algorithms that check for palindromes are a common programming interview question. 
 
 ## Example 
 
-The word "radar" is spelled the exact same both forwards and backwards, and as a result is a palindrome. 
-The phrase "race car" is another common palindrome that is spelled the same forwards and backwards. 
+The word racecar is a valid palindrome, as it is a word spelled the same when backgrounds and forwards. The examples below shows valid cases of the palindrome `racecar`.
 
-## Algorithm 
+```
+raceCar
+r a c e c a r
+r?a?c?e?c?a?r?
+RACEcar
+```
 
-To check for palindromes, the first and last characters of a String must be compared for equality. 
-When the first and last characters are the same, they are removed from the String, resulting in a 
-substring starting with the second character and ending at the second to last character. 
+## Algorithm 
 
-In this implementation of a palindrome checker, recursion is used to check each substring of the 
-original String. 
+To check for palindromes, a string's characters are compared starting from the beginning and end then moving inward toward the middle of the string while maintaining the same distance apart. In this implementation of a palindrome algorithm, recursion is used to check each of the characters on the left-hand side and right-hand side moving inward.
 
 ## The code 
 
 Here is a recursive implementation of this in Swift: 
 
 ```swift
-func palindromeCheck (text: String?) -> Bool {
-  if let text = text {
-    let mutableText = text.trimmingCharacters(in: NSCharacterSet.whitespaces()).lowercased()
-    let length: Int = mutableText.characters.count
-    
-    guard length >= 1 else {
-      return false
-    }
-
-    if length == 1 {
-      return true
-    } else if mutableText[mutableText.startIndex] == mutableText[mutableText.index(mutableText.endIndex, offsetBy: -1)] {
-      let range = Range<String.Index>(mutableText.index(mutableText.startIndex, offsetBy: 1)..<mutableText.index(mutableText.endIndex, offsetBy: -1))
-      return palindromeCheck(text: mutableText.substring(with: range))
-    }
+func isPalindrome(_ str: String) -> Bool {
+  let strippedString = str.replacingOccurrences(of: "\\W", with: "", options: .regularExpression, range: nil)
+  let length = strippedString.characters.count
+
+  if length > 1 {
+    return palindrome(strippedString.lowercased(), left: 0, right: length - 1)
   }
 
   return false
 }
+
+private func palindrome(_ str: String, left: Int, right: Int) -> Bool {
+  if left >= right {
+    return true
+  }
+
+  let lhs = str[str.index(str.startIndex, offsetBy: left)]
+  let rhs = str[str.index(str.startIndex, offsetBy: right)]
+
+  if lhs != rhs {
+    return false
+  }
+
+  return palindrome(str, left: left + 1, right: right - 1)
+}
+```
+
+This algorithm has a two-step process.
+
+1. The first step is to pass the string to validate as a palindrome into the `isPalindrome` method. This method first removes occurrences of non-word pattern matches `\W` [Regex reference](http://regexr.com). It is written with two \\ to escape the \ in the String literal. 
+
+```swift
+let strippedString = str.replacingOccurrences(of: "\\W", with: "", options: .regularExpression, range: nil)
 ```
 
+The length of the string is then checked to make sure that the string after being stripped of non-word characters is still in a valid length. It is then passed into the next step after being lowercased.
 
-This code can be tested in a playground using the following: 
+2. The second step is to pass the string in a recursive method. This method takes a string, a left index, and a right index. The method checks the characters of the string using the indexes to compare each character on both sides. The method checks if the left is greater or equal to the right if so the entire string has been run through without returning false so the string is equal on both sides thus returning true. 
+```swift
+if left >= right {
+  return true
+}
+```
+If the check doesn't pass it continues to get the characters at the specified indexes and compare each. If they are not the same the method returns false and exits. 
+```swift
+let lhs = str[str.index(str.startIndex, offsetBy: left)]
+let rhs = str[str.index(str.startIndex, offsetBy: right)]
 
+if lhs != rhs {
+  return false
+}
+```
+If they are the same the method calls itself again and updates the indexes accordingly to continue to check the rest of the string. 
 ```swift
-palindromeCheck(text: "Race car")
+return palindrome(str, left: left + 1, right: right - 1)
+```
+
+Step 1:
+`race?C ar -> raceCar -> racecar`
+
+Step 2:
 ```
+|     |
+racecar -> r == r
 
-Since the phrase "Race car" is a palindrome, this will return true. 
+ |   |
+racecar -> a == a
+
+  | |
+racecar -> c == c
+
+   |
+racecar -> left index == right index -> return true
+```
 
 ## Additional Resources
 
 [Palindrome Wikipedia](https://en.wikipedia.org/wiki/Palindrome)
 
 
-*Written by [Stephen Rutstein](https://github.com/srutstein21)*
+*Written by [Joshua Alvarado](https://github.com/https://github.com/lostatseajoshua)*

Palindromes/Test/Palindromes.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+func isPalindrome(_ str: String) -> Bool {
+    let strippedString = str.replacingOccurrences(of: "\\W", with: "", options: .regularExpression, range: nil)
+    let length = strippedString.characters.count
+    
+    if length > 1 {
+        return palindrome(strippedString.lowercased(), left: 0, right: length - 1)
+    }
+    return false
+}
+
+private func palindrome(_ str: String, left: Int, right: Int) -> Bool {
+    if left >= right {
+        return true
+    }
+    
+    let lhs = str[str.index(str.startIndex, offsetBy: left)]
+    let rhs = str[str.index(str.startIndex, offsetBy: right)]
+    
+    if lhs != rhs {
+        return false
+    }
+    
+    return palindrome(str, left: left + 1, right: right - 1)
+}