Swift 2 remove object from array with contains string have - arrays

Question

I have string array in Swift 2:
var myList : [String] = []
And I have dynamic strings inside and I explode them with * character myList examples:
print(myList[0]) output = 2018-04-05*type2*namea
print(myList[1]) output = 2018-04-05*type2*nameb
print(myList[2]) output = 2018-04-05*type3*nameb
print(myList[3]) output = 2018-04-06*type3*named
I want to delete objects have type3 ones in myList:
IF IN same date AND same name AND have type2 ones
Must be my strings like that:
print(myList[0]) output = 2018-04-05*type2*namea
print(myList[1]) output = 2018-04-05*type2*nameb
print(myList[2]) output = 2018-04-06*type3*named
This item below must be deleted:
print(myList[2]) output = 2018-04-05*type3*nameb
I want to delete type3 ones in myList if before have type2 with same date and same name basically.
Explain:
2018-04-05*type2*nameb and 2018-04-05*type3*nameb, have same date and same name but 2018-04-05*type3*nameb before have type2(2018-04-05*type2*nameb) ? so 2018-04-05*type3*nameb line must be delete
How can I do it?

Answer 1

This playground code will do what you want:
//: Playground - noun: a place where people can play
import UIKit
let myList = ["2018-04-05*type2*namea",
"2018-04-05*type2*nameb",
"2018-04-05*type3*nameb",
"2018-04-06*type3*named"]
//Define a class that lets us map from a string to a date, type, and name string
class ListEntry {
let fullString: String
//define lazy vars for all the substrings
lazy var subStrings: [Substring] = fullString.split(separator: "*")
lazy var dateString = subStrings[0]
lazy var typeString = subStrings[1]
lazy var nameString = subStrings[2]
//Create a failable initializer that takes a full string as input
//and tries to break it into exactly 3 substrings
//using the "*" sparator
init?(fullString: String) {
self.fullString = fullString
if subStrings.count != 3 { return nil }
}
}
print("---Input:---")
myList.forEach { print($0) }
print("------------")
//Map our array of strings to an array of ListEntry objects
let items = myList.compactMap { ListEntry(fullString: $0) }
//Create an output array
var output: [String] = []
//Loop through each item in the array of ListEntry objects, getting an index for each
for (index,item) in items.enumerated() {
//If this is the first item, or it dosn't have type == "type3", add it to the output
guard index > 0,
item.typeString == "type3" else {
print("Adding item", item.fullString)
output.append(item.fullString)
continue
}
let previous = items[index-1]
/*
Add this item if
-the previous type isn't "type2"
-the previous item's date doesn't match this one
-the previous item's name doesn't match this one
*/
guard previous.typeString == "type2",
item.dateString == previous.dateString,
item.nameString == previous.nameString else {
print("Adding item", item.fullString)
output.append(item.fullString)
continue
}
print("Skipping item ", item.fullString)
}
print("\n---Output:---")
output.forEach { print($0) }
The output of the code above is:
---Input:---
2018-04-05*type2*namea
2018-04-05*type2*nameb
2018-04-05*type3*nameb
2018-04-06*type3*named
------------
Adding item 2018-04-05*type2*namea
Adding item 2018-04-05*type2*nameb
Skipping item 2018-04-05*type3*nameb
Adding item 2018-04-06*type3*named
---Output:---
2018-04-05*type2*namea
2018-04-05*type2*nameb
2018-04-06*type3*named

Answer 2

I'll start you off with a simple (albeit hack-ish) approach:
let myList = ["2018-04-05*type2*namea", "2018-04-05*type2*nameb", "2018-04-05*type3*nameb", "2018-04-06*type3*named"]
Define the function:
func swapLastTwoComps(_ s: String) -> String {
let parts = s.split(separator: "*")
return [parts[0], parts[2], parts[1]].joined(separator: "*")
}
Now if you do
let myListS = myList.map {swapLastTwoComps($0)}.sorted()
you get
["2018-04-05*namea*type2", "2018-04-05*nameb*type2", "2018-04-05*nameb*type3", "2018-04-06*named*type3"]
i.e. the sort has left strings to be removed adjacent and to the right of their equivalent, so now you can easily loop through the array and remove the strings you want (because you only need to compare each String's prefix with the String immediately to its left to determine whether it should be removed).
Once you've done that, map swapLastTwoComps over the final array again to restore the strings to their previous format.