Question

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

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

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

我无法确定如何设置numsarray以包含函数的两个输入start和end之间的所有数字，我在下面的数组中的内容是伪码。当我使用一组特定数字进行尝试时，每个return中的所有case都会给我一个错误，指出我无法将该表达式转换为[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)

Answer 1

您的函数的返回类型是[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
}

Answer 2

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

Answer 3

看来你的意图是使用＆＃34; Fizz Buzz值构建一个数组＆＃34;在开始和结束之间，包括在内。因此，考虑到这一点，我们不需要创建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增量会产生非常显着的差异。

如何在swift中循环包含两个整数之间所有数字的数组？

3 个答案: