Swift 是否向 return 提供任何内置函数来附加到不可变数组的结果？

Question

写的问答，想知道有没有更简单的写法：

var nums = [1,2,3]

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

我知道我能做到：

var nums = [1,2,3]

let sum1 = nums.reduce([Int]()){
    return [=13=] + []
}

但这是一个黑客。

为了更好地解释这一点，我想更接近下面的示例（来自 docs），只是它应该用于数组：

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

编辑：

自从有人问我想要实现什么：

我在做 leetcode 的 group Anagram's challenge。

我的解决方案是：

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 [=15=] + [.string]
            })
            return total + [strings]
        })
        return finalAnswer
    }
}


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

Answer 1

reduce(..) 必须知道它使用的是哪种类型。要推断这一点，它可以使用 return 类型或第一个参数的类型。所以你也可以这样写：

var nums = [1,2,3]

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

[] 无法替换为，因为值和集合之间的 +- 运算符未定义。

Answer 2

嗯，+ 运算符怎么样？

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

Answer 3

没有。但是你可以添加它：

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

Answer 4

您的代码试图将复杂结构转换为数组数组。您可以为此使用 map。

这应该有效：

let finalAnswer = answers.map { answer in
    answer.words.map {
        [=10=].string
    }
}

编辑： 我能够使用最少的代码解决它：

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

        return Dictionary(grouping: processedWords, by: { [=11=].key }).map { groupedValue in
            groupedValue.value.map {
                [=11=].value
            }
        }
    }
}

Answer 5

你把 "final answers" 的计算复杂化了。它可能只是：

return answers.map { [=10=].words.map { [=10=].string } }

Swift 是否向 return 提供任何内置函数来附加到不可变数组的结果？

Does Swift offer any built-in function to return the result of appending to an immutable array?

arrays

immutability

higher-order-functions

swift