überprüfen, ob ein Array alle Werte eines anderen Arrays enthält (haben alle Benutzer Aufträge zugewiesen?)

Question

Gesamt Noob Frage, aber ich habe mein Bestes getan und kann nicht herausfinden, wie ich über mein Array iterieren und feststellen, ob es enthält alle Werte eines anderen Arrays.

Hier ist meine Array-Klasse (dailyJobs):

class JobsAndHabits { 

var name: String 
var multiplier: Double 
var assigned: String 
var order: Int 

init(jobName: String, jobMultiplier: Double, jobAssign: String, jobOrder: Int) { 

    self.name = jobName 
    self.multiplier = jobMultiplier 
    self.assigned = jobAssign 
    self.order = jobOrder 
} 

Und hier ist die Klasse I (Benutzer) überprüfen möchten:

class UserClass { 

var imageURL: String 
var firstName: String 
var birthday: Int 
var passcode: Int 
var gender: String 
var childParent: String 

init(userProfileImageURL: String, userFirstName: String, userBirthday: Int, userPasscode: Int, userGender: String, isUserChildOrParent: String) { 

    self.imageURL = userProfileImageURL 
    self.firstName = userFirstName 
    self.birthday = userBirthday 
    self.passcode = userPasscode 
    self.gender = userGender 
    self.childParent = isUserChildOrParent 

} 

Hier ist meine JSON Baum, wenn das hilft:

{ 
"-Kw2SkmAqo3G_cVFP26Y" : { 
"assigned" : "Aiden", 
"multiplier" : 1, 
"name" : "table", 
"order" : 2 
}, 
"-Kw2SkmAqo3G_cVFP26Z" : { 
"assigned" : "Mom", 
"multiplier" : 1, 
"name" : "dishes", 
"order" : 3 
}, 
"-Kw2SyhJNkjKNQ-sKBeT" : { 
"assigned" : "Sophie", 
"multiplier" : 1, 
"name" : "floors", 
"order" : 0 
}, 
"-Kw2SyhJNkjKNQ-sKBeU" : { 
"assigned" : "Savannah", 
"multiplier" : 1, 
"name" : "laundry", 
"order" : 1 
}, 
"-Kw7H3pY2L5PzLLdd6qD" : { 
"assigned" : "Dad", 
"multiplier" : 1, 
"name" : "another daily test", 
"order" : 4 
}, 
"-Kw7HAWwAvv5ZjYuNOrg" : { 
"assigned" : "Sophie", 
"multiplier" : 1, 
"name" : "daily job testsaroo!", 
"order" : 5 } 

Und hier ist das, was ich versucht habe:

Versuch # 1:

var tempArray = [String]() 
    for user in self.users { 
     for job in self.dailyJobs { 
      if job.assigned == user.firstName { 
       print(user.firstName,"has a job",job.name) 
       tempArray.append(user.firstName) 
      } 
     } 
    } 
    for user in self.users { 
     if tempArray.contains(user.firstName) { 
      print("true") 
     } else { 
      print("false") 
     } 
    } 

Versuch # 2: (dies noch nicht einmal kompilieren)

for job in self.dailyJobs { 
     if self.users.contains(where: job) { 
      print(true) 
     } 
    } 

Versuch # 3: druckt "Failed" wiederholt.

Wie überprüfe ich, ob jedem Benutzer in meinem Benutzer-Array mindestens ein Job zugewiesen ist? Mit anderen Worten, wie stelle ich sicher, dass innerhalb des dailyJobs Arrays jeder user.firstName mindestens einmal dargestellt wird?

Ich denke, ich muss eine Art Schleife machen, aber ich bin mir nicht sicher, wie es weitergeht. Kann mir jemand in die richtige Richtung zeigen? Im Moment gehe ich nur im Kreis (wenn du das Wortspiel verzeihst).

Answer 1

Versuch # 1 ist in der Nähe. Sie können nur sagen, es ist true nach allen Benutzern Überprüfung:

func areAllAssigned(users: [UserClass], tempArray: [String]) -> Bool { 
    for user in users { 
    if !tempArray.contains(user.firstName) { 
     return false 
    } 
    } 
    return true 
} 

In der Tat, müssen Sie nicht die äußere for Schleife benötigen:

for job in self.dailyJobs { 
    print(job.assigned, "has a job", job.name) 
    tempArray.append(job.assigned) 
} 

areAllAssigned(users: self.users, tempArray: tempArray) 

Answer 2

Nach this answer zu finden, habe ich es zu arbeiten.

Mein Code:

func checkIfAllUsersHaveDailyJobs() -> Bool { 
    var tempArray = [String]() 
    for job in self.dailyJobs { 
     for user in self.users { 
      if job.assigned == user.firstName { 
       print(user.firstName,"has the job:",job.assigned) 
       tempArray.append(user.firstName) 
      } 
     } 
    } 
    print(tempArray.count) 

    for user in self.users { 
     if !tempArray.contains(user.firstName) { 
      return false 
     } 
    } 
    return true 
} 

Answer 3

die Klasse Make Hashable anzupassen und Set zu verwenden. Sie brauchen nicht so viel Code.

Aktualisiert

Sie brauchen nicht Hashable hier zu verwenden. Ich habe deine Frage missverstanden. Ich habe den Code vereinfacht, aber im Grunde hat es das, was Sie brauchen.

struct JobsAndHabits { 
    let assigned: String 
} 

struct UserClass { 
    let firstName: String 
} 

let users = [UserClass(firstName: "person_a"), 
      UserClass(firstName: "person_b"), 
      UserClass(firstName: "person_c"), 
      UserClass(firstName: "person_d")] 

let jobs = [JobsAndHabits(assigned: "person_a"), 
      JobsAndHabits(assigned: "person_c")] 

let names = Set(users.map({ return $0.firstName })) 
let assigned = Set(jobs.map({ return $0.assigned })) 

print(names.subtracting(assigned)) // users who doesn't have jobs 

Answer 4

So geht's mit Sets (ohne die Klassen Hashable zu machen).

if Set(users.map{firstName}).isSubset(of:dailyJobs.map{$0.assigned}) 
{ 
    // all users are assigned to at least one job 
} 
else 
{ 
    let employed = Set(dailyJobs.map{$0.assigned}) 
    let jobless = users.filter{ !employed.contains($0.firstName) } 
}