add couple of solutions

Author: boudhayan

Algorithm Solutions In Swift.xcodeproj/project.pbxproj

@@ -1,4 +1,13 @@
 import Foundation
 
+//************** BEGIN REVISE *************************
+// 1. Count And Say
+// 2. Is Ugly Number
+// 3. Sort By Parity II
+// 4. Missing Ranges
+// 5. Array Pair Sum
+//************** END REVISE ***************************
 
 
+
+//*************** START PRACTICE *************************

Algorithm Solutions In Swift/main.swift

@@ -0,0 +1,28 @@
+//
+//  ArrayIntersection.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func arraysIntersection(_ arr1: [Int], _ arr2: [Int], _ arr3: [Int]) -> [Int] {
+    var p1 = 0, p2 = 0, p3 = 0
+    var intersections = [Int]()
+    while p1 < arr1.count, p2 < arr2.count, p3 < arr3.count {
+        if arr1[p1] == arr2[p2], arr2[p2] == arr3[p3] {
+            intersections.append(arr1[p1])
+            p1 += 1
+            p2 += 1
+            p3 += 1
+        } else {
+            if arr1[p1] < arr2[p2] {
+                p1 += 1
+            } else if arr2[p2] < arr3[p3] {
+                p2 += 1
+            } else {
+                p3 += 1
+            }
+        }
+    }
+    return intersections
+}

LeetCode/Array Intersection/ArrayIntersection.swift

@@ -0,0 +1,29 @@
+//
+//  ArrayPairSum.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func arrayPairSum(_ nums: [Int]) -> Int {
+    var maxSum = 0
+    let offset = 10000
+    var container = Array(repeating: 0, count: 2 * offset + 1)
+    for num in nums {
+        container[num + offset] += 1
+    }
+    var pickNext = true
+    for i in 0..<container.count {
+        while container[i] > 0 {
+            if pickNext {
+                maxSum += i - offset
+            }
+            pickNext.toggle()
+            container[i] -= 1
+        }
+    }
+    return maxSum
+}
+
+
+//print(arrayPairSum([6,2,6,5,1,2]))

LeetCode/Array Pair Sum/ArrayPairSum.swift

@@ -0,0 +1,20 @@
+//
+//  CanConstruct.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func canConstruct(_ ransomNote: String, _ magazine: String) -> Bool {
+    let ransomFreq = Dictionary(ransomNote.map { ($0, 1) }, uniquingKeysWith: +)
+    let magazineFreq = Dictionary(magazine.map { ($0, 1) }, uniquingKeysWith: +)
+
+    for (ch, needed) in ransomFreq {
+        if magazineFreq[ch, default: 0] < needed {
+            return false
+        }
+    }
+    return true
+}
+
+//print(canConstruct("aa", "aab"))

LeetCode/Can Construct/CanConstruct.swift

@@ -0,0 +1,35 @@
+//
+//  CountAndSay.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func countAndSay(_ n: Int) -> String {
+    guard n > 1 else { return "1" }
+    var current = Array("1")
+    for _ in 2...n {
+        var next: [Character] = []
+        var i = 0
+        while i < current.count {
+            let key = current[i]
+            var j = i
+            while j < current.count, current[j] == key {
+                j += 1
+            }
+            let count = j - i
+            for digit in String(count) {
+                next.append(digit)
+            }
+            next.append(key)
+
+            i = j
+        }
+        current = next
+    }
+    return String(current)
+
+}
+
+
+//print(countAndSay(15))

LeetCode/Count And Say/CountAndSay.swift

@@ -0,0 +1,28 @@
+//
+//  Count Negatives.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func countNegatives(_ grid: [[Int]]) -> Int {
+    var count = 0
+    for row in grid {
+        var left = 0, right = row.count - 1
+        var negativeIndex = -1
+        while left <= right {
+            let mid = (left + right) / 2
+            if row[mid] < 0 {
+                negativeIndex = mid
+                right = mid - 1
+            } else {
+                left = mid + 1
+            }
+        }
+        count += negativeIndex == -1 ? 0 : (row.count - negativeIndex)
+    }
+    return count
+}
+
+//let grid = [[3, 2], [1, 0]]
+//print(countNegatives(grid))

LeetCode/Count Negatives/Count Negatives.swift

@@ -0,0 +1,22 @@
+//
+//  CountPairs.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func countPairs(_ nums: [Int], _ target: Int) -> Int {
+    let numbers = nums.sorted()
+    var left = 0, right = nums.count - 1
+    var pairs = 0
+    while left < right {
+        let sum = numbers[left] + numbers[right]
+        if sum < target {
+            pairs += (right - left)
+            left += 1
+        } else {
+            right -= 1
+        }
+    }
+    return pairs
+}

LeetCode/Count Pairs/CountPairs.swift

@@ -0,0 +1,40 @@
+//
+//  FindDifferences.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func findTheDifference(_ s: String, _ t: String) -> Character {
+    var sContainer: [Int] = Array(repeating: 0, count: 26)
+    var tContainer: [Int] = Array(repeating: 0, count: 26)
+
+    for char in s {
+        sContainer[Int(char.asciiValue ?? 0)%97] += 1
+    }
+    for char in t {
+        tContainer[Int(char.asciiValue ?? 0)%97] += 1
+    }
+    var i = 0, j = 0
+    while i < sContainer.count, j < tContainer.count {
+        if sContainer[i] != tContainer[j] {
+            return Character(UnicodeScalar(97+i)!)
+        }
+        i += 1
+        j += 1
+    }
+    return Character("")
+}
+
+func findTheDifferenceXOR(_ s: String, _ t: String) -> Character {
+    var xorValue: UInt8 = 0
+    for byte in s.utf8 {
+        xorValue ^= byte
+    }
+    for byte in t.utf8 {
+        xorValue ^= byte
+    }
+    return Character(UnicodeScalar(xorValue))
+}
+
+//print(findTheDifferenceXOR("abcd", "abcde"))

LeetCode/Find Differences String/FindDifferences.swift

@@ -0,0 +1,26 @@
+//
+//  FixedPoint.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by littlebanana on 17/03/26.
+//
+
+func fixedPoint(_ arr: [Int]) -> Int {
+    var i = 0, j = arr.count - 1
+    var smallestIndex = arr.count
+    while i <= j {
+        let mid = (i + j) / 2
+        if mid == arr[mid] {
+            smallestIndex = min(smallestIndex, mid)
+            j = mid - 1
+        } else if arr[mid] < mid {
+            i = mid + 1
+        } else {
+            j = mid - 1
+        }
+    }
+    return smallestIndex == arr.count ? -1 : smallestIndex
+}
+
+
+//print(fixedPoint([-10,-5,-2,0,4,5,6,7,8,9,10]))