Swift: نطاقات وتسلسلات Swift: Range وClosedRange وStride

let seatA1 = "A1"
let seatA2 = "A2"
// ... 200 variables total

let rows = "ABCDEFGHIJKLMNOPQRST"
let seatsPerRow = 10
for row in rows {
    for seat in 1...seatsPerRow {
        print("\(row)\(seat)", terminator: " ")
    }
    print()
}

// Closed range: includes 1 through 5
let closed = 1...5
for i in closed {
    print(i, terminator: " ")
}
print()
// Half-open range: includes 1 through 4
let halfOpen = 1..<5
for i in halfOpen {
    print(i, terminator: " ")
}
print()
// Reverse traversal
for i in (1...5).reversed() {
    print(i, terminator: " ")
}
print()

let numbers = [10, 20, 30, 40, 50, 60, 70]
let firstThree = numbers[0..<3]
print(firstThree)
let fromSecond = numbers[2...]
print(fromSecond)
let firstFour = numbers[...3]
print(firstFour)

// ============================================
// Using ranges in switch for grade classification
// ============================================
let scores = [95, 82, 67, 54, 43, 78, 91]
for score in scores {
    let grade: String
    switch score {
    case 90...100:
        grade = "A"
    case 80..<90:
        grade = "B"
    case 70..<80:
        grade = "C"
    case 60..<70:
        grade = "D"
    case 0..<60:
        grade = "F"
    default:
        grade = "Invalid"
    }
    print("Score \(score): Grade \(grade)")
}

// 0 to 9, step 2
for i in stride(from: 0, to: 10, by: 2) {
    print(i, terminator: " ")
}
print()
// 10 to 0, step -3
for i in stride(from: 10, through: 0, by: -3) {
    print(i, terminator: " ")
}
print()
// Floating-point stepping
for temp in stride(from: 0.0, to: 1.0, by: 0.25) {
    print("\(Int(temp * 100))%", terminator: " ")
}
print()

struct FibonacciSequence: Sequence {
    let count: Int
    func makeIterator() -> FibonacciIterator {
        return FibonacciIterator(count: count)
    }
}
struct FibonacciIterator: IteratorProtocol {
    let count: Int
    var current = 0
    var nextValue = 1
    var index = 0
    mutating func next() -> Int? {
        guard index < count else { return nil }
        defer { index += 1 }
        let result = current
        current = nextValue
        nextValue = result + current
        return result
    }
}
let fib = FibonacciSequence(count: 10)
for num in fib {
    print(num, terminator: " ")
}
print()

// ============================================
// Generate temperature conversion table with stride
// ============================================
print("Celsius\tFahrenheit")
print("-----------------")
for celsius in stride(from: 0.0, through: 100.0, by: 10.0) {
    let fahrenheit = celsius * 9 / 5 + 32
    print("\(Int(celsius))\t\(Int(fahrenheit))")
}
print()
print("Fahrenheit\tCelsius")
print("-------------------")
for f in stride(from: 212.0, through: 32.0, by: -20.0) {
    let c = (f - 32) * 5 / 9
    print("\(Int(f))\t\t\(Int(c))")
}

let names = ["Alice", "Bob", "Charlie", "Diana"]
let scores = [88, 92, 75, 95]
for (name, score) in zip(names, scores) {
    print("\(name): \(score)")
}
let short = ["A", "B", "C"]
let long = [1, 2, 3, 4, 5]
for pair in zip(short, long) {
    print(pair)
}

let fruits = ["Apple", "Banana", "Orange", "Grape"]
for (index, fruit) in zip(1..., fruits) {
    print("\(index). \(fruit)")
}

// ============================================
// Assign attendees to seats using zip and ranges
// ============================================
let attendees = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank"]
let rows = ["A", "B", "C", "D"]
let seatsPerRow = 4
var allSeats: [String] = []
for row in rows {
    for seat in 1...seatsPerRow {
        allSeats.append("\(row)\(seat)")
    }
}
print("=== Seat Assignments ===")
for (attendee, seat) in zip(attendees, allSeats) {
    print("\(seat): \(attendee)")
}
let vipCount = 2
let vipSeats = allSeats.prefix(vipCount)
let vipAttendees = attendees.prefix(vipCount)
print("\n=== VIP Section ===")
for (person, seat) in zip(vipAttendees, vipSeats) {
    print("\(seat): \(person)")
}

// ============================================
// Exam seating chart and grade analysis
// Combining Range / Stride / zip / Sequence
// ============================================
import Foundation
let examRows = 5
let cols = 4
print("=== Exam Seating Chart ===")
for row in 0..<examRows {
    let rowLabel = Character(UnicodeScalar(65 + row)!)
    for col in 1...cols {
        print("\(rowLabel)\(col)", terminator: "\t")
    }
    print()
}
let students = ["Alice", "Bob", "Charlie", "Diana", "Eve",
                "Frank", "Grace", "Henry", "Ivy", "Jack",
                "Kevin", "Leo", "Mia", "Noah", "Olivia",
                "Paul", "Quinn", "Rose", "Sam", "Tina"]
let examSeats = examRows * cols
let assignedIndices = stride(from: 0, to: min(students.count, examSeats), by: 1)
print("\n=== Seat Assignments ===")
for (index, studentIndex) in zip(assignedIndices, 0..<students.count) {
    let row = index / cols
    let col = index % cols + 1
    let rowLabel = Character(UnicodeScalar(65 + row)!)
    print("\(rowLabel)\(col): \(students[studentIndex])")
}
print("\n=== Score Report ===")
var scores: [String: Int] = [:]
for student in students.prefix(examSeats) {
    scores[student] = Int.random(in: 40...100)
}
let gradeRanges: [ClosedRange<Int>: String] = [
    90...100: "A",
    80...89: "B",
    70...79: "C",
    60...69: "D",
    0...59: "F"
]
var gradeCount: [String: Int] = ["A": 0, "B": 0, "C": 0, "D": 0, "F": 0]
for (student, score) in scores.sorted(by: { $0.key < $1.key }) {
    var grade = "F"
    for (range, g) in gradeRanges {
        if range.contains(score) {
            grade = g
            break
        }
    }
    gradeCount[grade]! += 1
    print("\(student): \(score) -- \(grade)")
}
print("\n=== Grade Distribution ===")
for grade in ["A", "B", "C", "D", "F"] {
    let count = gradeCount[grade]!
    let bar = String(repeating: "#", count: count)
    print("\(grade): \(bar) (\(count))")
}