Swift 2 удалить объект из массива со строкой

Question

У меня есть строковый массив в Swift 2:

var myList              : [String] = []

И у меня внутри есть динамические строки, и я взрываю их с помощью * символов myList Примеры:

   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

Я хочуудаляемые объекты имеют type3 единиц в myList:

IF IN такая же дата AND то же имя И имеют type2 ones

Должно быть, мои строки такие:

   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

Этот пункт ниже должен быть удален:

   print(myList[2])  output = 2018-04-05*type3*nameb

Я хочу удалить type3 вmyList, если раньше имел type2 с той же датой и тем же именем в основном.

Объясните:

2018-04-05*type2*nameb и 2018-04-05*type3*nameb, с той же датой и тем же именем , но 2018-04-05*type3*nameb прежде чем type2 (2018-04-05 * type2 * nameb)?поэтому 2018-04-05 * type3 * строка имени должна быть delete

Как я могу это сделать?

Answer 1

Этот код игровой площадки будет делать то, что вы хотите:

//: 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) }

Вывод кода выше:

---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

Я начну с простого (хотя и хакерского) подхода:

let myList = ["2018-04-05*type2*namea", "2018-04-05*type2*nameb", "2018-04-05*type3*nameb", "2018-04-06*type3*named"]

Определите функцию:

func swapLastTwoComps(_ s: String) -> String {
    let parts = s.split(separator: "*")
    return [parts[0], parts[2], parts[1]].joined(separator: "*")
}

Теперь, если вы сделаете

let myListS = myList.map {swapLastTwoComps($0)}.sorted() 

вы получаете

["2018-04-05*namea*type2", "2018-04-05*nameb*type2", "2018-04-05*nameb*type3", "2018-04-06*named*type3"]

то есть сортировка оставляет строки, которые должны быть удалены рядом и справа от их эквивалента, так что теперь вы можете легко проходить по массиву и удалять нужные строки (потому что вам нужно только сравнить префикс каждой строки со строкой непосредственно слева от нее, чтобы определить, следует ли ее удалять).

Как только вы это сделаете, снова сопоставьте swapLastTwoComps окончательный массив, чтобы восстановить строки в их прежнем формате.