Swift: SwiftのSetと辞書チュートリアル：集合演算とDictionaryの使い方を解説

let oldTags = ["VIP", "HighSpender", "NewUser"]
let newTags = ["VIP", "PromoSensitive", "HighSpender"]
var merged: [String] = []
for tag in oldTags + newTags {
    if !merged.contains(tag) {
        merged.append(tag)
    }
}

let oldTags: Set = ["VIP", "HighSpender", "NewUser"]
let newTags: Set = ["VIP", "PromoSensitive", "HighSpender"]
let merged = oldTags.union(newTags)
let common = oldTags.intersection(newTags)
print("Merged: \(merged)")
print("Common: \(common)")

var fruits: Set<String> = ["Apple", "Banana", "Orange"]
fruits.insert("Apple")
fruits.insert("Grape")
fruits.remove("Banana")
print(fruits.contains("Apple"))
print(fruits.count)

let a: Set = [1, 2, 3, 4, 5]
let b: Set = [4, 5, 6, 7, 8]
print("Union: \(a.union(b).sorted())")
print("Intersection: \(a.intersection(b).sorted())")
print("A - B: \(a.subtracting(b).sorted())")
print("Symmetric Diff: \(a.symmetricDifference(b).sorted())")

// ============================================
// Managing user tags with Sets
// ============================================
var userTags: Set<String> = ["VIP", "NewUser", "HighSpender"]
let campaignTags: Set = ["VIP", "PromoSensitive"]
let excludeTags: Set = ["Inactive", "Fraud"]
userTags.insert("iOSUser")
userTags.insert("VIP")
let targetUsers = campaignTags.subtracting(excludeTags)
print("Target tags: \(targetUsers)")
let vipHighSpender = userTags.intersection(["VIP", "HighSpender"])
print("VIP high spenders: \(vipHighSpender)")
let allActive = userTags.union(campaignTags).subtracting(excludeTags)
print("All active tags: \(allActive.sorted())")

var scores: [String: Int] = [:]
var populations = [
    "New York": 8_336_817,
    "Los Angeles": 3_979_576,
    "Chicago": 2_693_976
]
populations["Houston"] = 2_320_268
populations["New York"] = 8_400_000
populations["Chicago"] = nil
if let nyPopulation = populations["New York"] {
    print("NY population: \(nyPopulation)")
}

let capitals = [
    "USA": "Washington DC",
    "UK": "London",
    "Japan": "Tokyo",
    "France": "Paris"
]
for (country, city) in capitals {
    print("\(country): \(city)")
}
print("Countries: \(capitals.keys.sorted())")
print("Capitals: \(capitals.values.sorted())")

// ============================================
// Managing inventory with Dictionary
// ============================================
var inventory: [String: Int] = [
    "Laptop": 15,
    "Mouse": 50,
    "Keyboard": 30
]
inventory["Monitor"] = 10
inventory["Mouse"]! += 20
if let laptopStock = inventory["Laptop"], laptopStock > 0 {
    inventory["Laptop"] = laptopStock - 1
    print("Shipped 1 Laptop")
}
let product = "Tablet"
if let stock = inventory[product] {
    print("\(product): \(stock) units")
} else {
    print("\(product) not found in inventory")
}
print("\n=== Inventory Report ===")
for (product, quantity) in inventory {
    let status = quantity < 20 ? "Low stock" : "In stock"
    print("\(product): \(quantity) units -- \(status)")
}

struct Product: Hashable {
    let id: Int
    let name: String
}
var cart: [Product: Int] = [:]
let laptop = Product(id: 1001, name: "Laptop")
cart[laptop] = 2
print("Cart items: \(cart.count)")

var cityTags: [String: Set<String>] = [
    "Paris": ["Eiffel Tower", "Louvre"],
    "Tokyo": ["Shibuya", "Sensoji"]
]
cityTags["Paris"]?.insert("Arc de Triomphe")
cityTags["London"] = ["Big Ben", "Tower Bridge"]
for (city, landmarks) in cityTags {
    print("\(city): \(landmarks.sorted().joined(separator: ", "))")
}

// ============================================
// User group stats with Dictionary and Set
// ============================================
let userLanguages: [String: Set<String>] = [
    "Alice": ["Swift", "Python", "JavaScript"],
    "Bob": ["Python", "Java", "Go"],
    "Charlie": ["Swift", "Kotlin", "JavaScript"],
    "Diana": ["Java", "C#", "Python"]
]
let swiftUsers = userLanguages.filter { $0.value.contains("Swift") }
print("Swift developers: \(swiftUsers.count)")
let allLanguages = userLanguages.values.reduce([]) { $0.union($1) }
print("All languages: \(allLanguages.sorted())")
let fullStack = userLanguages.filter { $0.value.count >= 3 }
for (name, langs) in fullStack {
    print("Full stack: \(name) -- \(langs.sorted().joined(separator: ", "))")
}

// ============================================
// User profile tagging system
// Combining Set and Dictionary concepts
// ============================================
import Foundation
struct UserProfile: Hashable {
    let id: Int
    let name: String
    var tags: Set<String>
}
var users: [Int: UserProfile] = [
    1: UserProfile(id: 1, name: "Alice", tags: ["VIP", "HighSpender", "iOS"]),
    2: UserProfile(id: 2, name: "Bob", tags: ["NewUser", "Android"]),
    3: UserProfile(id: 3, name: "Charlie", tags: ["VIP", "Android", "HighSpender"]),
    4: UserProfile(id: 4, name: "Diana", tags: ["iOS", "NewUser"])
]
let campaignTags: Set = ["VIP", "iOS"]
let excludeTags: Set = ["Fraud", "Inactive"]
var targetUserIds: Set<Int> = []
for (id, profile) in users {
    let effectiveTags = profile.tags.subtracting(excludeTags)
    if !effectiveTags.intersection(campaignTags).isEmpty {
        targetUserIds.insert(id)
    }
}
print("=== Campaign Target Users ===")
for id in targetUserIds.sorted() {
    if let user = users[id] {
        print("\(user.name) -- tags: \(user.tags.sorted().joined(separator: ", "))")
    }
}
print("\n=== Adding Tag: BetaTester ===")
for id in users.keys {
    users[id]?.tags.insert("BetaTester")
}
print("\n=== Tag Distribution ===")
var tagCounts: [String: Int] = [:]
for (_, profile) in users {
    for tag in profile.tags {
        tagCounts[tag, default: 0] += 1
    }
}
for (tag, count) in tagCounts.sorted(by: { $0.value > $1.value }) {
    print("\(tag): \(count) users")
}