0

我想要做的是使用从start到end连续的任何整数数组运行“fizzbizz”函数，然后根据以下每种情况输出一个对象数组，整数或字符串。

在这个例子中，我试图在一个从start整数 1 到end整数 15 的数组上运行函数。

随着 fizzbuzz 函数的运行，对于该范围内的每个整数，我想检查它是否可以被 3 和/或 5 整除。如果它可以被 3 而不是 5 整除，我想返回“Fizz”，如果它不能整除由 3 到 5，我想返回“Buzz”，依此类推。

我无法弄清楚如何设置numsarray为包含函数的两个输入之间的所有数字，start并且end，我在下面的数组中拥有的是伪代码。当我用一组特定数字尝试它时，每个中的所有returns 都会case给我一个错误，指出我无法将该表达式转换为 type 的表达式[Any]。

我使用[Any]是因为我会将整数和字符串都推入数组中，所以我不想让它成为一种特定类型。

func fizzinAndBuzzin(start: Int, end: Int) -> [Any]{

    let numsarray = [start...end]

    for number in numsarray {
        switch (number % 3 == 0, number % 5 == 0) {
        case (true, false):
            return "Fizz"
        case (false, true):
            return "Buzz"
        case (true, true):
            return "FizzBuzz"
        default:
            return int(start)
        }
    }  
}

fizzinAndBuzzin(1, 15)
4

3 回答 3

4

您的函数的返回类型是[Any]，它是任意数组。您不是返回数组，而是返回单个对象。像这样更改您的函数定义：

func fizzinAndBuzzin(start: Int, end: Int) -> Any {

然后你的代码没有多大意义。你的目标是回归吗

[1,2,"fizz",4,"buzz","fizz",7,8,"fizz","buzz"]

等等

如果是这样，那么您不希望在每种情况下都返回，您想要构建一个数组：

func fizzinAndBuzzin(start: Int, end: Int) -> [Any]
{
    //Create an empty array of Any
    var numsArray = [Any]()

    for number in start...end 
    {
        switch (number % 3 == 0, number % 5 == 0) {
        case (true, false):
            numsArray.append("Fizz")
        case (false, true):
            numsArray.append("Buzz")
        case (true, true):
            numsArray.append("FizzBuzz")
        default:
            numsArray.append(number)
        }
    }  
    return numsArray
}
于 2015-04-22T22:44:32.857 回答
3

该map函数正是为此目的而设计的，即获取一个数组，对每个元素应用闭包，然后从中创建一个新数组。例如：

let foo = [1, 2, 3]
let bar = foo.map { number -> Int in
    return number * 2
}

这将分配bar给：

[2, 4, 6]

因此，适用map于您的原始问题，它看起来像：

func fizzinAndBuzzin(start: Int, end: Int) -> [Any] {
    let numsarray = Array(start ... end)
    return numsarray.map() { number -> Any in
        switch (number % 3 == 0, number % 5 == 0) {
        case (true, false):
            return "Fizz"
        case (false, true):
            return "Buzz"
        case (true, true):
            return "FizzBuzz"
        default:
            return number
        }
    }
}
于 2015-04-22T23:08:48.383 回答
1

看来您的意图是在开始和结束之间构建一个包含“Fizz Buzz 值”的数组，包括在内。所以考虑到这一点，我们不需要创建一个let数组，而是一个空var数组并填充它。

我们的switch语句应该将值加载到这个数组中。但我实际上会在这里选择一些抽象，所以首先，一个函数只取一个Int并返回适当的值：

func fizzBuzzify(value: Int) -> Any {
    switch (value % 3, value % 5) {
    case (0, 0):
        return "FizzBuzz"
    case (0, _):
        return "Fizz"
    case (_, 0):
        return "Buzz"
    default:
        return value
    }
}

现在，让我们修复我们的fizzinAndBuzzin函数：

func fizzinAndBuzzin(start: Int, end: Int) -> [Any] {
    var values = Array<Any>()
    values.reserveCapacity(end-start+1)

    for index in start...end {
        values.append(fizzBuzzify(index))
    }

    return values
}

这种方法一次性预分配整个数组的内存（我们事先知道它有多大）。与使用依赖的方法相比，对于非常大的增量，start这将产生非常显着的差异。end.append

于 2015-04-22T22:45:40.923 回答