Предлагает ли Swift встроенную функцию для возврата результата добавления в неизменяемый массив?

Question

Написание вопроса и ответа от здесь , мне любопытно узнать, есть ли какой-нибудь более простой способ написать следующее:

var nums = [1,2,3]

let sum1 = nums.reduce([Int]()){
    let temp = $0
    temp.append($1)
    return temp
}

Я знаю, что могу сделать:

var nums = [1,2,3]

let sum1 = nums.reduce([Int]()){
    return $0 + [$1]
}

Но это похоже на взлом.

Чтобы объяснить это лучше, я хочу приблизиться к примеру (из docs ) ниже, просто так должно быть для массива:

let numbers = [1, 2, 3, 4]
let numberSum = numbers.reduce(0, { x, y in
    x + y
})

---

EDIT:

Поскольку люди спрашивали, чего я пытался достичь:

Я делал вызов Анааграммы группы leetcode .

Мое решение было:

struct WordTraits: Equatable{
    let count: Int
    let charactersSet: Set<Character>
}

struct Word: Equatable{
    let string: String
    let wordTraits: WordTraits
}


class Solution{

    func groupAnagrams(_ strs: [String]) -> [[String]]{

        var words : [Word] = []
        var answers : [(traits: WordTraits, words: [Word])] = []

        var count = 0
        strs.forEach{ str in
            count += 1
            let count = str.count
            let string = str
            let characterSet = Set(str)

            let wordTraits = WordTraits(count: count, charactersSet: characterSet)

            let word = Word(string: string, wordTraits: wordTraits)
            words.append(word)

        }
        while words.count != 0{
            let word = words[0]
            let traits = word.wordTraits
            var isWordAdded = false
            for (i, answer) in answers.enumerated(){
                if answer.traits == traits{
                    answers[i].words.append(word)
                    isWordAdded = true
                    break
                }
            }
            if !isWordAdded{
                answers.append((traits: traits, words:[word]))
            }
            words.removeFirst()
        }

        let emptyArray : [[String]] = []
        let finalAnswer = answers.reduce(emptyArray, { total, answer in
            let strings : [String] = answer.words.reduce([String](), {

                return $0 + [$1.string]
            })
            return total + [strings]
        })
        return finalAnswer
    }
}


let s = Solution()
print(s.groupAnagrams(["ate", "eta", "beta", "abet"])) // [["ate", "eta"], ["beta", "abet"]]

Answer 1

Вы значительно усложнили свои вычисления "окончательных ответов".Это может быть просто:

return answers.map { $0.words.map { $0.string } }

Answer 2

Ваш код пытается преобразовать сложную структуру в массив массивов. Вы можете использовать map для этого.

Это должно работать:

let finalAnswer = answers.map { answer in
    answer.words.map {
        $0.string
    }
}

Edit: Я смог решить это, используя минимальный код:

class Solution {
    func groupAnagrams(_ words: [String]) -> [[String]] {
        let processedWords = words.map {
            (key: String($0.sorted()), value: $0)
        }

        return Dictionary(grouping: processedWords, by: { $0.key }).map { groupedValue in
            groupedValue.value.map {
                $0.value
            }
        }
    }
}

Answer 3

Хм, а как насчет оператора +?

let nums = [1, 3, 5]
let more = nums + [7]

Answer 4

Неа.Но вы можете добавить его:

extension Array {
    func appending(_ newElement: Element) -> Array<Element> {
        return self + [newElement]
    }
    func appending(contentsOf sequence: Sequence) -> Array<Element> {
        return self + sequence
    }
}

Answer 5

reduce(..) должен знать, с каким типом он работает.Чтобы вывести это, он может использовать тип возвращаемого значения или тип первого аргумента.Таким образом, вы также можете написать:

var nums = [1,2,3]

let sum1: [Int] = nums.reduce([]){
    return $0 + [$1]
}

[$1] не может быть заменено на $1, так как + -оператор между значением и коллекцией не определен.